SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Peopledatalabs MCP with CrewAI

Connect CrewAI to Peopledatalabs MCP. Enrich this email with full person profile, standardize and clean this company name, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Peopledatalabs logoPeopledatalabs
Api Key

Peopledatalabs delivers B2B data enrichment and identity resolution APIs. Supercharge your apps with accurate, up-to-date business and contact data.

26 Tools

Introduction

This guide walks you through connecting Peopledatalabs to CrewAI using the Composio tool router. By the end, you'll have a working Peopledatalabs agent that can enrich person and company data, search people and companies, clean location and school data, and search job postings through natural language commands.

This guide will help you understand how to give your CrewAI agent real control over a Peopledatalabs account through Composio's Peopledatalabs MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Peopledatalabs with

Claude CodeClaude CoworkOpenAI Agents SDKClaude Agent SDKGrok BotMuseCodexOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Get a Composio API key and configure your Peopledatalabs connection
  • Set up CrewAI with an MCP enabled agent
  • Create a Tool Router session or standalone MCP server for Peopledatalabs
  • Build a conversational loop where your agent can execute Peopledatalabs operations

What is CrewAI?

CrewAI is a powerful framework for building multi-agent AI systems. It provides primitives for defining agents with specific roles, creating tasks, and orchestrating workflows through crews.

Key features include:

  • Agent Roles: Define specialized agents with specific goals and backstories
  • Task Management: Create tasks with clear descriptions and expected outputs
  • Crew Orchestration: Combine agents and tasks into collaborative workflows
  • MCP Integration: Connect to external tools through Model Context Protocol

What is the Peopledatalabs MCP server, and what's possible with it?

The People Data Labs MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your People Data Labs account. It provides structured and secure access to company records, job postings, data cleaning tools, and dataset schemas, so your agent can search companies, find job postings, standardize company and location data, suggest field values, and inspect available data fields on your behalf.

  • Company record search: Have your agent find companies that match specific criteria using flexible business data queries.
  • Company data cleanup: Let the agent standardize company details from a business name, website, or profile URL.
  • Location standardization: Direct your agent to turn raw location text into clean, structured geographic information.
  • Job posting discovery: Instruct your agent to search People Data Labs job postings using criteria relevant to your recruiting or market research.
  • Schema and field guidance: Have your agent inspect person or company data fields, review allowed values, and suggest completions for partial company, skill, or title text.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step08 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Python 3.9 or higher
  • A Composio account and API key
  • A Peopledatalabs connection authorized in Composio
  • An OpenAI API key for the CrewAI LLM
  • Basic familiarity with Python
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

bash
pip install composio crewai crewai-tools[mcp] python-dotenv
What's happening:
  • composio connects your agent to Peopledatalabs via MCP
  • crewai provides Agent, Task, Crew, and LLM primitives
  • crewai-tools[mcp] includes MCP helpers
  • python-dotenv loads environment variables from .env
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
OPENAI_API_KEY=your_openai_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID scopes the session to your account
  • OPENAI_API_KEY lets CrewAI use your chosen OpenAI model
5

Import dependencies

python
import os
from composio import Composio
from crewai import Agent, Task, Crew
from crewai_tools import MCPServerAdapter
import dotenv

dotenv.load_dotenv()

COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

if not COMPOSIO_API_KEY:
    raise ValueError("COMPOSIO_API_KEY is not set")
if not COMPOSIO_USER_ID:
    raise ValueError("COMPOSIO_USER_ID is not set")
What's happening:
  • CrewAI classes define agents and tasks, and run the workflow
  • MCPServerHTTP connects the agent to an MCP endpoint
  • Composio will give you a short lived Peopledatalabs MCP URL
6

Create a Composio Tool Router session for Peopledatalabs

python
composio_client = Composio(api_key=COMPOSIO_API_KEY)
session = composio_client.create(user_id=COMPOSIO_USER_ID, toolkits=["peopledatalabs"])

url = session.mcp.url
What's happening:
  • You create a Peopledatalabs only session through Composio
  • Composio returns an MCP HTTP URL that exposes Peopledatalabs tools
7

Initialize the MCP Server

python
server_params = {
    "url": url,
    "transport": "streamable-http",
    "headers": {"x-api-key": COMPOSIO_API_KEY},
}

with MCPServerAdapter(server_params) as tools:
    agent = Agent(
        role="Search Assistant",
        goal="Help users search the internet effectively",
        backstory="You are a helpful assistant with access to search tools.",
        tools=tools,
        verbose=False,
        max_iter=10,
    )
What's Happening:
  • Server Configuration: The code sets up connection parameters including the MCP server URL, streamable HTTP transport, and Composio API key authentication.
  • MCP Adapter Bridge: MCPServerAdapter acts as a context manager that converts Composio MCP tools into a CrewAI-compatible format.
  • Agent Setup: Creates a CrewAI Agent with a defined role (Search Assistant), goal (help with internet searches), and access to the MCP tools.
  • Configuration Options: The agent includes settings like verbose=False for clean output and max_iter=10 to prevent infinite loops.
  • Dynamic Tool Usage: Once created, the agent automatically accesses all Composio Search tools and decides when to use them based on user queries.
8

Create a CLI Chatloop and define the Crew

python
print("Chat started! Type 'exit' or 'quit' to end.\n")

conversation_context = ""

while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    conversation_context += f"\nUser: {user_input}\n"
    print("\nAgent is thinking...\n")

    task = Task(
        description=(
            f"Conversation history:\n{conversation_context}\n\n"
            f"Current request: {user_input}"
        ),
        expected_output="A helpful response addressing the user's request",
        agent=agent,
    )

    crew = Crew(agents=[agent], tasks=[task], verbose=False)
    result = crew.kickoff()
    response = str(result)

    conversation_context += f"Agent: {response}\n"
    print(f"Agent: {response}\n")
What's Happening:
  • Interactive CLI Setup: The code creates an infinite loop that continuously prompts for user input and maintains the entire conversation history in a string variable.
  • Input Validation: Empty inputs are ignored to prevent processing blank messages and keep the conversation clean.
  • Context Building: Each user message is appended to the conversation context, which preserves the full dialogue history for better agent responses.
  • Dynamic Task Creation: For every user input, a new Task is created that includes both the full conversation history and the current request as context.
  • Crew Execution: A Crew is instantiated with the agent and task, then kicked off to process the request and generate a response.
  • Response Management: The agent's response is converted to a string, added to the conversation context, and displayed to the user, maintaining conversational continuity.

Complete Code

Here's the complete code to get you started with Peopledatalabs and CrewAI:

python
from crewai import Agent, Task, Crew, LLM
from crewai_tools import MCPServerAdapter
from composio import Composio
from dotenv import load_dotenv
import os

load_dotenv()

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

if not GOOGLE_API_KEY:
    raise ValueError("GOOGLE_API_KEY is not set in the environment.")
if not COMPOSIO_API_KEY:
    raise ValueError("COMPOSIO_API_KEY is not set in the environment.")
if not COMPOSIO_USER_ID:
    raise ValueError("COMPOSIO_USER_ID is not set in the environment.")

# Initialize Composio and create a session
composio = Composio(api_key=COMPOSIO_API_KEY)
session = composio.create(
    user_id=COMPOSIO_USER_ID,
    toolkits=["peopledatalabs"],
)
url = session.mcp.url

# Configure LLM
llm = LLM(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY"),
)

server_params = {
    "url": url,
    "transport": "streamable-http",
    "headers": {"x-api-key": COMPOSIO_API_KEY},
}

with MCPServerAdapter(server_params) as tools:
    agent = Agent(
        role="Search Assistant",
        goal="Help users with internet searches",
        backstory="You are an expert assistant with access to Composio Search tools.",
        tools=tools,
        llm=llm,
        verbose=False,
        max_iter=10,
    )

    print("Chat started! Type 'exit' or 'quit' to end.\n")

    conversation_context = ""

    while True:
        user_input = input("You: ").strip()

        if user_input.lower() in ["exit", "quit", "bye"]:
            print("\nGoodbye!")
            break

        if not user_input:
            continue

        conversation_context += f"\nUser: {user_input}\n"
        print("\nAgent is thinking...\n")

        task = Task(
            description=(
                f"Conversation history:\n{conversation_context}\n\n"
                f"Current request: {user_input}"
            ),
            expected_output="A helpful response addressing the user's request",
            agent=agent,
        )

        crew = Crew(agents=[agent], tasks=[task], verbose=False)
        result = crew.kickoff()
        response = str(result)

        conversation_context += f"Agent: {response}\n"
        print(f"Agent: {response}\n")

Conclusion

You now have a CrewAI agent connected to Peopledatalabs through Composio's Tool Router. The agent can perform Peopledatalabs operations through natural language commands.

Next steps:

  • Add role-specific instructions to customize agent behavior
  • Plug in more toolkits for multi-app workflows
  • Chain tasks for complex multi-step operations
TOOLS

Supported Tools

Every Peopledatalabs action and event your agent gets out of the box.

Bulk Retrieve Persons

Retrieve up to 100 People Data Labs person records by persistent ID.

Clean company data

Cleans and standardizes company information based on a name, website, or profile URL; providing at least one of these inputs is highly recommended for meaningful results.

Clean company data (POST)

Tool to clean and standardize company data using POST method.

Clean location data

Cleans and standardizes a raw, unformatted location string into a structured representation, provided the input is a recognizable geographical place.

Clean location data (POST)

Tool to clean and standardize location data using POST method.

Clean school data

Cleans and standardizes school information; provide at least one of the school's name, website, or profile for optimal results.

Clean school data (POST)

Tool to clean and standardize school data using POST method.

Enrich Bulk Company Data

Tool to enrich up to 100 companies in a single request using the Bulk Company Enrichment API.

Enrich bulk person data

Enrich up to 100 person profiles in one Bulk Person Enrichment request using supported identifiers and matching parameters.

Enrich Company Data

Enrich company data from People Data Labs with firmographics and employee counts using a company ID, name, social profile, ticker, or website.

Enrich IP Data

Enrich an IP address with People Data Labs company data and, where available and requested, IP location, metadata, and person data.

Enrich job title data

Enrich a job title with a cleaned title, similar titles, and relevant skills.

Enrich person data

Enriches person data using various identifiers; requires a primary ID (profile, email, phone, email_hash, lid, pdl_id) OR a name (full, or first and last) combined with another demographic detail (e.

Enrich skill data

Retrieves detailed, standardized information for a given skill by querying the People Data Labs Skill Enrichment API; for best results, provide a recognized professional skill or area of expertise.

Autocomplete field suggestions

Provides autocompletion suggestions for a specific field (e.

Get autocomplete suggestions (POST)

Tool to get autocompletion suggestions using POST method for complex query parameters.

Get column details

Look up predefined enum values and their descriptions for a specified column.

Get schema

Retrieves the schema, including field names, descriptions, and data types, for 'person' or 'company' entity types.

Get subject requests

Retrieve a redirect URL for the authenticated account's person data subject requests, for privacy compliance review.

Identify person data

Identify person profiles in People Data Labs using attributes such as email, phone, profile URL, name, company, or location.

People Search with Elasticsearch

Search People Data Labs person profiles using an Elasticsearch DSL query, with criteria such as job title, skills, company, and location.

Query person changelog

Query the person changelog between dataset versions for updates, additions, deletions, merges, and opt-outs.

Retrieve person

Retrieve one person deterministically by persistent People Data Labs ID.

Company Search with Elasticsearch

Performs a search for company profiles within People Data Labs using a custom Elasticsearch Domain Specific Language (DSL) query.

Search Company Records (POST)

Tool to search and filter company records from the full Company Dataset using Elasticsearch or SQL queries via POST method.

Search job postings

Search PDL's Job Posting Dataset using one filter mode and cursor pagination.

FRAMEWORKS

How to build Peopledatalabs MCP Agent with another framework

Claude Code logo

Claude Code

Use Peopledatalabs MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Peopledatalabs MCP with Claude Cowork

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Peopledatalabs MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Peopledatalabs MCP with Claude Agent SDK

Grok Bot logo

Grok Bot

Use Peopledatalabs MCP with Grok Bot

Muse logo

Muse

Use Peopledatalabs MCP with Muse

Codex logo

Codex

Use Peopledatalabs MCP with Codex

OpenClaw logo

OpenClaw

Use Peopledatalabs MCP with OpenClaw

Hermes logo

Hermes

Use Peopledatalabs MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Peopledatalabs MCP with Atomic Agent

Google ADK logo

Google ADK

Use Peopledatalabs MCP with Google ADK

LangChain logo

LangChain

Use Peopledatalabs MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Peopledatalabs MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Peopledatalabs MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Peopledatalabs MCP with LlamaIndex

Pydantic AI logo

Pydantic AI

Use Peopledatalabs MCP with Pydantic AI

AutoGen logo

AutoGen

Use Peopledatalabs MCP with AutoGen

FAQ

Frequently asked questions

Start with Peopledatalabs.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Peopledatalabs tool your agent needs.Free to start.

Start building