DEV Community: AMAAN SARFARAZ

Build an AI Agent to Export LinkedIn Search Results to Google Sheets

AMAAN SARFARAZ — Tue, 20 Jan 2026 09:28:21 +0000

Ever spent hours manually searching LinkedIn and copying profile data into spreadsheets? What if an AI agent could do all that for you with a simple command like "Find 100 CEOs in the United States and export to Google Sheets"?

In this article, I'll show you how to build exactly that—an AI-powered agent that automates LinkedIn profile searching and Google Sheets export. We'll implement it using four different agentic frameworks so you can choose the one that fits your tech stack.

The Problem

Building lead lists, candidate pipelines, or market research databases from LinkedIn is tedious:

Manual searching: Hours browsing for the right profiles
Copy-paste nightmare: Moving data into spreadsheets one by one
Inconsistent data: Different formats and missing fields
Rate limiting risks: Manual scraping can get your account restricted

The Solution: An AI Agent

We'll build an agent that:

Understands natural language commands
Searches LinkedIn via ConnectSafely.ai API (no scraping, platform-compliant)
Formats the data consistently
Exports directly to Google Sheets or JSON

Four Framework Implementations

I've implemented this agent in four different frameworks:

Framework	Language	Interface
AutoGen	Python	Streamlit Web
CrewAI	Python	Streamlit Web
LangGraph	TypeScript	CLI
Mastra	TypeScript	Web UI

Let's look at each one!

1. AutoGen Implementation (Python)

AutoGen from Microsoft uses a modular architecture with a single assistant agent.

# agents/assistant.py
from tools import search_people, export_to_sheets

class LinkedInExportAssistant:
    def __init__(self):
        self.tools = [
            search_people,
            export_to_sheets,
            export_to_json
        ]
        self.assistant = create_assistant_agent(
            api_key=os.getenv("GEMINI_API_KEY"),
            model="gemini-2.5-pro",
            tools=self.tools
        )

    async def execute_async(self, command: str):
        result = await self.assistant.run(task=command)
        return clean_response(result)

The Streamlit UI makes it easy to interact:

# App.py
command = st.chat_input("Enter your command...")
if command:
    result = client.execute(command=command)
    st.markdown(result)

Run it:

cd autogen
uv sync
uv run streamlit run App.py

2. CrewAI Implementation (Python)

CrewAI uses a task-based approach with built-in memory:

# agents/agents.py
from crewai import Agent, LLM
from crewai.tools import tool

@tool("Search LinkedIn People")
def search_people(keywords: str, location: str = None):
    """Search for LinkedIn profiles."""
    # API call to ConnectSafely.ai
    pass

agent = Agent(
    role="LinkedIn Export Specialist",
    goal="Search LinkedIn profiles and export results",
    tools=[search_people, export_to_sheets],
    llm=LLM(model="gemini/gemini-2.5-pro"),
    memory=True,
)

Run it:

cd crewai
uv sync
uv run streamlit run App.py

3. LangGraph Implementation (TypeScript)

LangGraph uses a state graph architecture for complex workflows:

// agents/linkedin-export-agent.ts
import { StateGraph } from "@langchain/langgraph";

const workflow = new StateGraph(AgentState)
  .addNode("agent", callModel)
  .addNode("tools", toolNode)
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue, {
    tools: "tools",
    end: "__end__",
  })
  .addEdge("tools", "agent");

export const linkedInExportAgent = workflow.compile();

Tools are defined with Zod schemas:

// tools/search-people.ts
export const searchPeopleTool = tool(
  async ({ keywords, location, title, limit }) => {
    const res = await fetch(
      "https://api.connectsafely.ai/linkedin/search/people",
      {
        method: "POST",
        headers: { Authorization: `Bearer ${API_TOKEN}` },
        body: JSON.stringify({ keywords, location, title, limit }),
      }
    );
    return JSON.stringify(await res.json());
  },
  {
    name: "search-people",
    schema: z.object({
      keywords: z.string(),
      location: z.string().optional(),
      title: z.string().optional(),
      limit: z.number().default(100),
    }),
  }
);

Run it:

cd langGraph
bun install
bun run dev

4. Mastra Implementation (TypeScript)

Mastra offers the simplest configuration with built-in memory:

// agents/linkedin-export-agent.ts
import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";

export const linkedInExportAgent = new Agent({
  name: "LinkedIn to Sheets Export Agent",
  model: "google/gemini-3-flash-preview",
  instructions: linkedInExportAgentInstructions,
  tools: {
    searchPeopleTool,
    exportToSheetsTool,
    exportToJsonTool,
  },
  memory: new Memory({
    storage: new LibSQLStore({ url: "file:./mastra.db" }),
  }),
});

Run it:

cd mastra
bun install
bun run dev

The ConnectSafely.ai API

All implementations use ConnectSafely.ai for LinkedIn data access:

Platform-compliant: No scraping, no ban risk
Bearer token auth: Simple API key authentication
Rich data: Full profile information
Rate limiting: Built-in protection

Example API call:

const response = await fetch(
  "https://api.connectsafely.ai/linkedin/search/people",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${CONNECTSAFELY_API_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      keywords: "CEO SaaS",
      location: "United States",
      title: "Head of Growth",
      limit: 100,
    }),
  }
);

Setting Up Google Sheets Export

Create a Google Cloud project
Enable Google Sheets API
Create OAuth credentials:
- Go to APIs & Services → Credentials
- Create OAuth client ID (Desktop app type)
- Generate refresh token using OAuth Playground
- Required scopes: https://www.googleapis.com/auth/spreadsheets, https://www.googleapis.com/auth/drive

# .env
GOOGLE_CLIENT_ID=your_oauth_client_id
GOOGLE_CLIENT_SECRET=your_oauth_client_secret
GOOGLE_REFRESH_TOKEN=your_refresh_token

Which Framework Should You Choose?

If you want...	Choose
Modular Python code	AutoGen
Task-based workflows	CrewAI
Complex stateful flows	LangGraph
Quick setup with built-in UI	Mastra

Try It Yourself

The full source code is available on GitHub:

git clone https://github.com/ConnectSafelyAI/agentic-framework-examples
cd agentic-framework-examples/linkedin-to-sheets-export

Each framework has its own README with detailed setup instructions.

What's Next?

This is just the beginning! You could extend this agent to:

Schedule automated searches
Filter results by company size or industry
Add email enrichment
Build automated outreach sequences

Questions? Drop them in the comments below!

Found this useful? Give it a ❤️ and share with your network.

Want more AI agent tutorials? Follow me for weekly updates!

Build a LinkedIn Export CLI Agent with LangGraph

AMAAN SARFARAZ — Tue, 20 Jan 2026 09:25:55 +0000

LangGraph brings state machine thinking to AI agents. In this tutorial, we'll build a CLI-based agent that searches LinkedIn and exports results using TypeScript.

What We're Building

A LangGraph agent that:

Runs as an interactive CLI
Searches LinkedIn profiles
Exports to Google Sheets or JSON
Uses stateful workflows for reliability

Why LangGraph?

LangGraph excels at:

State Management: Explicit state transitions
Complex Flows: Conditional routing and loops
Error Recovery: Built-in retry and fallback
TypeScript: First-class TS support

Prerequisites

Bun runtime (v1.0+)
ConnectSafely.ai API token
Google Gemini API key
Google Sheets credentials (optional)

Project Structure

langGraph/
├── index.ts              # CLI entry point
├── package.json          # Dependencies
├── tsconfig.json         # TypeScript config
├── agents/
│   ├── linkedin-export-agent.ts  # State graph
│   └── config/
│       ├── model.ts      # Gemini setup
│       ├── prompt.ts     # System prompt
│       └── call-model.ts # Model invocation
├── cli/
│   ├── index.ts          # CLI runner
│   ├── interactive.ts    # Interactive mode
│   └── display.ts        # Output formatting
└── tools/
    ├── index.ts          # Tool exports
    ├── types.ts          # TypeScript types
    ├── search-people.ts
    └── googlesheet/            # Google Sheets export module
        ├── auth.ts             # OAuth authentication
        ├── client.ts           # Google Sheets API client
        ├── schemas.ts          # Zod schemas & headers
        └── export-to-sheets.ts # Export tool
    └── export-to-json.ts

Step 1: Setup

cd linkedin-to-sheets-export/agentic/langGraph
cp .env.example .env
# Add your API keys
bun install

Step 2: Define Types

// tools/types.ts
import { Annotation } from "@langchain/langgraph";
import { BaseMessage } from "@langchain/core/messages";

export interface Person {
  profileUrl: string;
  profileId: string;
  fullName: string;
  headline: string;
  location: string;
  company: string;
  connectionDegree: string;
  isPremium: boolean;
  isOpenToWork: boolean;
}

export const AgentState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: (a, b) => a.concat(b),
    default: () => [],
  }),
  searchResults: Annotation<Person[]>({
    reducer: (_, b) => b,
    default: () => [],
  }),
});

export type AgentStateType = typeof AgentState.State;

Step 3: Create Tools

LangGraph tools use Zod schemas:

// tools/search-people.ts
import { tool } from "@langchain/core/tools";
import { z } from "zod";

export const searchPeopleTool = tool(
  async ({ keywords, location, title, limit }) => {
    const token = process.env.CONNECTSAFELY_API_TOKEN;

    const response = await fetch(
      "https://api.connectsafely.ai/linkedin/search/people",
      {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${token}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ keywords, location, title, limit }),
      }
    );

    const data = await response.json();
    const result = Array.isArray(data) ? data[0] : data;
    const people = result?.people || [];

    const formatted = people.map((p: any) => ({
      profileUrl: p.profileUrl || "",
      fullName: `${p.firstName || ""} ${p.lastName || ""}`.trim(),
      headline: p.headline || "",
      location: p.location || "",
      company: extractCompany(p.headline || ""),
    }));

    return JSON.stringify({
      success: true,
      people: formatted,
      count: formatted.length,
    });
  },
  {
    name: "search-people",
    description: "Search for LinkedIn profiles by keywords, location, and title",
    schema: z.object({
      keywords: z.string().describe("Search terms"),
      location: z.string().optional().describe("Geographic filter"),
      title: z.string().optional().describe("Job title filter"),
      limit: z.number().default(100).describe("Max results"),
    }),
  }
);

function extractCompany(headline: string): string {
  const match = headline.match(/(?:at|@|-)\s*([^|]+?)(?:\s*\||$)/i);
  return match ? match[1].trim() : "";
}

Step 4: Export Tools

The export tool is modularized into separate files:

// tools/googlesheet/auth.ts
export async function getAccessToken(): Promise<string> {
  const res = await fetch("https://oauth2.googleapis.com/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      client_id: process.env.GOOGLE_CLIENT_ID!,
      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
      refresh_token: process.env.GOOGLE_REFRESH_TOKEN!,
      grant_type: "refresh_token",
    }),
  });
  const data = (await res.json()) as { access_token: string };
  return data.access_token;
}

// tools/googlesheet/export-to-sheets.ts
import { tool } from "@langchain/core/tools";
import { GoogleSheetsClient } from "./client.js";
import { exportToSheetsSchema } from "./schemas.js";

export const exportToSheetsTool = tool(
  async ({ people, spreadsheetId, spreadsheetTitle, sheetName }) => {
    const client = new GoogleSheetsClient();
    // Uses OAuth authentication
    // Handles spreadsheet creation and duplicate detection
  },
  {
    name: "export-to-sheets",
    description: "Export LinkedIn search results to Google Sheets. Automatically creates or updates spreadsheet with duplicate detection by Profile ID.",
    schema: exportToSheetsSchema,
  }
);

Step 5: Build the State Graph

// agents/linkedin-export-agent.ts
import { StateGraph } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { AgentState } from "../tools/types.js";
import { callModel, shouldContinue } from "./config/call-model.js";
import {
  searchPeopleTool,
  exportToSheetsTool,
  exportToJsonTool,
} from "../tools/index.js";

const tools = [searchPeopleTool, exportToSheetsTool, exportToJsonTool];
const toolNode = new ToolNode(tools);

const workflow = new StateGraph(AgentState)
  // Add nodes
  .addNode("agent", callModel)
  .addNode("tools", toolNode)

  // Define edges
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue, {
    tools: "tools",
    end: "__end__",
  })
  .addEdge("tools", "agent");

export const linkedInExportAgent = workflow.compile();

Step 6: Model Configuration

// agents/config/call-model.ts
import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { AIMessage } from "@langchain/core/messages";
import type { AgentStateType } from "../../tools/types.js";
import { SYSTEM_PROMPT } from "./prompt.js";

const model = new ChatGoogleGenerativeAI({
  model: "gemini-2.0-flash",
  temperature: 0.1,
}).bindTools([searchPeopleTool, exportToSheetsTool, exportToJsonTool]);

export async function callModel(state: AgentStateType) {
  const messages = [
    { role: "system", content: SYSTEM_PROMPT },
    ...state.messages,
  ];

  const response = await model.invoke(messages);
  return { messages: [response] };
}

export function shouldContinue(state: AgentStateType) {
  const lastMessage = state.messages[state.messages.length - 1];

  if (lastMessage instanceof AIMessage && lastMessage.tool_calls?.length) {
    return "tools";
  }
  return "end";
}

Step 7: CLI Interface

// cli/interactive.ts
import { input } from "@inquirer/prompts";
import { linkedInExportAgent } from "../agents/linkedin-export-agent.js";
import { HumanMessage } from "@langchain/core/messages";
import { displayResponse, displayWelcome } from "./display.js";

export async function runInteractive() {
  displayWelcome();

  let state = { messages: [], searchResults: [] };

  while (true) {
    const userInput = await input({
      message: "You:",
      theme: { prefix: "" },
    });

    if (userInput.toLowerCase() === "exit") {
      console.log("\nGoodbye!");
      break;
    }

    state.messages.push(new HumanMessage(userInput));

    console.log("\nAgent thinking...\n");

    const result = await linkedInExportAgent.invoke(state);
    state = result;

    const lastMessage = result.messages[result.messages.length - 1];
    displayResponse(lastMessage.content);
  }
}

Step 8: Entry Point

// index.ts
import "dotenv/config";
import { runInteractive } from "./cli/index.js";

async function main() {
  const args = process.argv.slice(2);

  if (args.includes("--help")) {
    console.log("\nLinkedIn Export Agent (LangGraph)\n");
    console.log("Usage: bun run dev\n");
    return;
  }

  await runInteractive();
}

main().catch(console.error);

Step 9: Run

bun run dev

Example Session

LinkedIn Export Agent (LangGraph)
================================

You: Search for 25 CTOs in Seattle

Agent thinking...

Found 23 profiles matching "CTOs in Seattle":

1. Alex Kim - CTO at CloudTech Inc
2. Maria Santos - Chief Technology Officer at StartupXYZ
3. David Park - CTO & Co-founder at AI Dynamics
...

You: Export those to Google Sheets

Agent thinking...

Successfully exported 23 profiles to Google Sheets.
URL: https://docs.google.com/spreadsheets/d/1abc123...

You: exit

Goodbye!

Key LangGraph Patterns

1. State Annotations

Define state with reducers:

const AgentState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: (a, b) => a.concat(b),  // Append messages
    default: () => [],
  }),
});

2. Conditional Edges

Route based on state:

.addConditionalEdges("agent", shouldContinue, {
  tools: "tools",
  end: "__end__",
})

3. Tool Node

Built-in tool execution:

const toolNode = new ToolNode(tools);
workflow.addNode("tools", toolNode);

Extending the Agent

Add Retries

import { retry } from "@langchain/langgraph";

const robustToolNode = retry(toolNode, { maxAttempts: 3 });

Add Human-in-the-Loop

workflow.addNode("human_review", async (state) => {
  const approved = await askForApproval(state);
  return { ...state, approved };
});

Troubleshooting

"Tool not found"

Check tool is in the tools array
Verify tool name matches schema

State not updating

Ensure reducer is defined correctly
Check you're returning state from nodes

Gemini rate limits

Add delays between requests
Use gemini-2.0-flash for faster responses

Resources

Questions? Drop them in the comments!

Export LinkedIn Data to Google Sheets with CrewAI

AMAAN SARFARAZ — Tue, 20 Jan 2026 09:24:28 +0000

CrewAI makes building AI agents intuitive with its task-oriented approach. In this tutorial, we'll build an agent that searches LinkedIn and exports results to Google Sheets.

What We're Building

A CrewAI agent that:

Searches LinkedIn profiles via natural language
Exports results to Google Sheets or JSON
Remembers context between commands
Runs in a Streamlit web interface

Why CrewAI?

CrewAI shines for:

Task-Based Design: Think in terms of jobs to be done
Built-in Memory: Automatic context management
Tool Decorators: Simple @tool syntax
Rapid Prototyping: Get agents running fast

Prerequisites

Python 3.10+
ConnectSafely.ai API token
Google Gemini API key
Google Sheets credentials (optional)

Project Structure

crewai/
├── App.py              # Streamlit UI
├── crew.py             # CrewAI wrapper
├── workflows.py        # Command handlers
├── pyproject.toml      # Dependencies
├── agents/
│   └── agents.py       # Agent definition
└── tools/
    ├── search_people_tool.py
    └── googlesheet/                 # Google Sheets export module
        ├── auth.py                  # OAuth authentication
        ├── client.py                # Google Sheets API client
        └── export_to_sheets.py      # Export tool
    └── export_to_json_tool.py

Step 1: Setup

cd linkedin-to-sheets-export/agentic/crewai
cp .env.example .env
# Add your API keys to .env
uv sync

Step 2: Create Tools with @tool Decorator

CrewAI uses decorators to define tools:

# tools/search_people_tool.py
import os
import requests
from crewai.tools import tool

@tool("Search LinkedIn People")
def search_people(
    keywords: str,
    location: str = None,
    title: str = None,
    limit: int = 100
) -> dict:
    """
    Search for LinkedIn profiles using ConnectSafely.ai API.

    Args:
        keywords: Search terms like "CEO SaaS" or "Software Engineer"
        location: Geographic filter like "San Francisco" or "United States"
        title: Job title filter like "Head of Growth"
        limit: Maximum results to return (default: 100)

    Returns:
        Dictionary with people list and count
    """
    api_token = os.getenv("CONNECTSAFELY_API_TOKEN")

    response = requests.post(
        "https://api.connectsafely.ai/linkedin/search/people",
        headers={
            "Authorization": f"Bearer {api_token}",
            "Content-Type": "application/json",
        },
        json={
            "keywords": keywords,
            "location": location,
            "title": title,
            "limit": min(limit, 100),
        },
        timeout=60,
    )

    data = response.json()
    if isinstance(data, list):
        data = data[0] if data else {}

    people = data.get("people", [])

    formatted = [{
        "profileUrl": p.get("profileUrl", ""),
        "fullName": f"{p.get('firstName', '')} {p.get('lastName', '')}".strip(),
        "headline": p.get("headline", ""),
        "location": p.get("location", ""),
    } for p in people]

    return {
        "success": True,
        "people": formatted,
        "count": len(formatted)
    }

Step 3: Export Tools

The export tool is modularized into separate files:

# tools/googlesheet/auth.py
import os
import requests

def get_access_token() -> str:
    """Get Google OAuth access token from refresh token."""
    response = requests.post(
        "https://oauth2.googleapis.com/token",
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        data={
            "client_id": os.getenv("GOOGLE_CLIENT_ID"),
            "client_secret": os.getenv("GOOGLE_CLIENT_SECRET"),
            "refresh_token": os.getenv("GOOGLE_REFRESH_TOKEN"),
            "grant_type": "refresh_token",
        },
    )
    return response.json()["access_token"]

# tools/googlesheet/client.py
import requests
from .auth import get_access_token

class GoogleSheetsClient:
    """Wrapper for Google Sheets API operations."""

    def create_spreadsheet(self, title: str, sheet_name: str, headers: list):
        # Creates spreadsheet with OAuth authentication
        pass

    def append_data(self, spreadsheet_id: str, sheet_name: str, values: list):
        # Appends rows using OAuth
        pass

# tools/googlesheet/export_to_sheets.py
from crewai.tools import tool
from .client import GoogleSheetsClient

@tool("Export to Google Sheets")
def export_to_sheets(
    people: list,
    spreadsheet_id: str = None,
    spreadsheet_title: str = None,
    sheet_name: str = "LinkedIn People"
) -> dict:
    """Export LinkedIn profiles to Google Sheets using OAuth authentication."""
    client = GoogleSheetsClient()
    # Uses OAuth authentication
    # Handles spreadsheet creation and duplicate detection

Step 4: Define the Agent

# agents/agents.py
from crewai import Agent
from langchain_google_genai import ChatGoogleGenerativeAI

from tools.search_people_tool import search_people
from tools.googlesheet.export_to_sheets import export_to_sheets
from tools.export_to_json_tool import export_to_json

def create_export_agent():
    """Create the LinkedIn Export Agent."""

    llm = ChatGoogleGenerativeAI(
        model="gemini-2.5-pro",
        temperature=0.1,
    )

    return Agent(
        role="LinkedIn Export Specialist",
        goal="Search LinkedIn profiles and export results to Google Sheets or JSON files",
        backstory="""You are an expert at finding professional profiles on LinkedIn
        and organizing the data for export. You understand search parameters,
        can interpret user requests, and efficiently export data to spreadsheets.""",
        tools=[search_people, export_to_sheets, export_to_json],
        llm=llm,
        memory=True,
        verbose=True,
    )

Step 5: Create the Crew Wrapper

# crew.py
from crewai import Crew, Task
from agents.agents import create_export_agent

class LinkedInExportCrew:
    def __init__(self):
        self.agent = create_export_agent()
        self.search_results = []

    def execute(self, command: str, context: str = None) -> dict:
        """Execute a command with the crew."""

        # Build task description
        task_desc = command
        if context:
            task_desc = f"{context}\n\nCurrent request: {command}"

        task = Task(
            description=task_desc,
            expected_output="A summary of the action taken and results",
            agent=self.agent,
        )

        crew = Crew(
            agents=[self.agent],
            tasks=[task],
            verbose=True,
        )

        result = crew.kickoff()

        return {
            "success": True,
            "result": str(result)
        }

Step 6: Build the UI

# App.py
import os
import streamlit as st
from dotenv import load_dotenv
from crew import LinkedInExportCrew

load_dotenv()

st.set_page_config(page_title="LinkedIn Export - CrewAI", page_icon="📊")
st.title("📊 LinkedIn to Sheets Export")
st.caption("Powered by CrewAI & ConnectSafely.ai")

# Initialize
if "crew" not in st.session_state:
    st.session_state.crew = LinkedInExportCrew()

if "messages" not in st.session_state:
    st.session_state.messages = []

if "context" not in st.session_state:
    st.session_state.context = ""

# Examples
with st.expander("Example Commands"):
    st.markdown("""
    - `Search for 50 CEOs in New York`
    - `Find software engineers in San Francisco`
    - `Export results to Google Sheets`
    - `Save as JSON`
    """)

# Chat history
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).write(msg["content"])

# Input
if command := st.chat_input("Enter command..."):
    st.session_state.messages.append({"role": "user", "content": command})
    st.chat_message("user").write(command)

    with st.chat_message("assistant"):
        with st.spinner("CrewAI working..."):
            result = st.session_state.crew.execute(
                command=command,
                context=st.session_state.context
            )

            response = result.get("result", "")
            st.markdown(response)

            st.session_state.messages.append({
                "role": "assistant",
                "content": response
            })

            # Update context
            st.session_state.context += f"\nUser: {command}\nAgent: {response}\n"

Step 7: Run

uv run streamlit run App.py

Key CrewAI Patterns

1. Tool Decorators

The @tool decorator is the cleanest way to define tools:

@tool("Tool Name")
def my_tool(param: str) -> dict:
    """Docstring becomes the tool description."""
    return {"result": "value"}

2. Agent Memory

Enable memory for context retention:

Agent(
    # ...
    memory=True,  # Enables conversation memory
)

3. Task-Based Execution

Each command becomes a task:

task = Task(
    description="What to do",
    expected_output="What success looks like",
    agent=agent,
)

Extending the Agent

Add Multiple Agents

researcher = Agent(role="Researcher", ...)
exporter = Agent(role="Data Exporter", ...)

crew = Crew(
    agents=[researcher, exporter],
    tasks=[research_task, export_task],
    process=Process.sequential,
)

Add Custom Memory

from crewai.memory import LongTermMemory

agent = Agent(
    # ...
    memory=True,
    long_term_memory=LongTermMemory(),
)

Troubleshooting

"Tool not found"

Ensure tools are passed to the Agent constructor
Check tool function names match what agent expects

Slow execution

CrewAI has overhead; consider caching results
Use verbose=False in production

Memory issues

Context can grow large; implement truncation
Clear context periodically

Resources

Questions? Drop them in the comments!

Build a LinkedIn to Google Sheets Export Agent with AutoGen

AMAAN SARFARAZ — Tue, 20 Jan 2026 09:21:44 +0000

Microsoft's AutoGen is a powerful framework for building multi-agent AI systems. In this tutorial, we'll build an agent that searches LinkedIn profiles and exports results directly to Google Sheets.

What We're Building

An AI agent that:

Understands natural language commands
Searches LinkedIn via ConnectSafely.ai API
Exports results to Google Sheets or JSON
Maintains conversation context

Why AutoGen?

AutoGen excels at:

Modular Architecture: Clean separation of concerns
Extensibility: Easy to add new tools and capabilities
Enterprise-Ready: Production-grade code patterns
Conversation Management: Built-in multi-turn support

Prerequisites

Python 3.10+
uv package manager
ConnectSafely.ai API token
Google Gemini API key
Google Sheets credentials (for Sheets export)

Project Structure

autogen/
├── App.py                    # Streamlit UI
├── autogen_client.py         # Client wrapper
├── workflows.py              # Command handlers
├── pyproject.toml            # Dependencies
├── agents/
│   ├── assistant.py          # Main agent
│   └── config/
│       ├── agent_factory.py  # Agent creation
│       ├── memory_manager.py # Context management
│       └── response_processor.py
└── tools/
    ├── search_people_tool.py
    └── googlesheet/                 # Google Sheets export module
        ├── auth.py                  # OAuth authentication
        ├── client.py                # Google Sheets API client
        └── export_to_sheets.py      # Export function
    └── export_to_json_tool.py

Step 1: Install Dependencies

cd linkedin-to-sheets-export/agentic/autogen
cp .env.example .env
# Edit .env with your API keys
uv sync

Step 2: Create the Search Tool

# tools/search_people_tool.py
import os
import requests
from typing import Dict, Any, Optional

def search_people(
    keywords: str,
    location: Optional[str] = None,
    title: Optional[str] = None,
    limit: int = 100
) -> Dict[str, Any]:
    """Search for LinkedIn profiles."""

    api_token = os.getenv("CONNECTSAFELY_API_TOKEN")

    response = requests.post(
        "https://api.connectsafely.ai/linkedin/search/people",
        headers={
            "Authorization": f"Bearer {api_token}",
            "Content-Type": "application/json",
        },
        json={
            "keywords": keywords,
            "location": location,
            "title": title,
            "limit": min(limit, 100),
        },
        timeout=60,
    )

    data = response.json()

    # Handle array wrapper
    if isinstance(data, list):
        data = data[0] if data else {}

    people = data.get("people", [])

    return {
        "success": True,
        "people": format_people(people),
        "count": len(people),
    }

def format_people(people):
    """Format profile data for export."""
    return [{
        "profileUrl": p.get("profileUrl", ""),
        "fullName": f"{p.get('firstName', '')} {p.get('lastName', '')}".strip(),
        "headline": p.get("headline", ""),
        "location": p.get("location", ""),
        "company": extract_company(p.get("headline", "")),
    } for p in people]

Step 3: Create the Export Tool

The export tool is modularized into separate files:

# tools/googlesheet/auth.py
import os
import requests

def get_access_token() -> str:
    """Get Google OAuth access token from refresh token."""
    response = requests.post(
        "https://oauth2.googleapis.com/token",
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        data={
            "client_id": os.getenv("GOOGLE_CLIENT_ID"),
            "client_secret": os.getenv("GOOGLE_CLIENT_SECRET"),
            "refresh_token": os.getenv("GOOGLE_REFRESH_TOKEN"),
            "grant_type": "refresh_token",
        },
    )
    return response.json()["access_token"]

# tools/googlesheet/export_to_sheets.py
from .client import GoogleSheetsClient

def export_to_sheets(
    people: list,
    spreadsheet_id: str = None,
    spreadsheet_title: str = None,
    sheet_name: str = "LinkedIn People"
) -> dict:
    """Export results to Google Sheets using OAuth authentication."""
    client = GoogleSheetsClient()
    # Uses OAuth authentication
    # Handles spreadsheet creation and duplicate detection

Step 4: Build the Agent

# agents/assistant.py
import os
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.google import GoogleGenAI

class LinkedInExportAssistant:
    def __init__(self):
        self.api_key = os.getenv("GEMINI_API_KEY")
        self.model = GoogleGenAI(
            model="gemini-2.5-pro",
            api_key=self.api_key
        )

        self.tools = [
            search_people,
            export_to_sheets,
            export_to_json
        ]

        self.assistant = AssistantAgent(
            name="linkedin_export_agent",
            model_client=self.model,
            tools=self.tools,
            system_message=self._get_system_prompt()
        )

    def _get_system_prompt(self):
        return """You are a LinkedIn Export Assistant that helps users:
1. Search for LinkedIn profiles by keywords, location, and job title
2. Export results to Google Sheets or JSON files

When users ask to search, use the search_people tool.
When users ask to export, use export_to_sheets or export_to_json.
Always summarize results clearly."""

    async def execute_async(self, command: str) -> str:
        result = await self.assistant.run(task=command)
        return str(result)

Step 5: Create the Streamlit UI

# App.py
import streamlit as st
from dotenv import load_dotenv
from autogen_client import LinkedInExportClient

load_dotenv()

st.set_page_config(page_title="LinkedIn Export (AutoGen)", page_icon="📊")
st.title("📊 LinkedIn to Sheets Export")

# Initialize client
if "client" not in st.session_state:
    st.session_state.client = LinkedInExportClient()

if "messages" not in st.session_state:
    st.session_state.messages = []

# Display chat history
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).write(msg["content"])

# Handle input
if command := st.chat_input("Enter command..."):
    st.session_state.messages.append({"role": "user", "content": command})
    st.chat_message("user").write(command)

    with st.chat_message("assistant"):
        with st.spinner("Working..."):
            result = st.session_state.client.execute(command)
            st.markdown(result["result"])
            st.session_state.messages.append({
                "role": "assistant",
                "content": result["result"]
            })

Step 6: Run the Application

uv run streamlit run App.py

Example Usage

You: Search for 50 CEOs in San Francisco

Agent: Found 47 profiles matching your criteria:
- John Smith - CEO at TechStartup Inc
- Jane Doe - CEO & Founder at AI Solutions
- ...

You: Export to Google Sheets

Agent: Successfully exported 47 profiles to Google Sheets.
URL: https://docs.google.com/spreadsheets/d/...

Key AutoGen Patterns

1. Modular Tool Design

Keep each tool focused on one task:

# Good: Single responsibility
def search_people(keywords, location, title, limit):
    # Only handles searching

def export_to_sheets(people, spreadsheet_id):
    # Only handles exporting

2. Memory Management

Use a dedicated memory manager:

class MemoryManager:
    def __init__(self):
        self.search_results = []

    def store_results(self, results):
        self.search_results = results

    def get_results(self):
        return self.search_results

3. Response Processing

Clean up agent responses:

def clean_response(result):
    """Extract clean text from agent result."""
    if hasattr(result, 'messages'):
        for msg in reversed(result.messages):
            if hasattr(msg, 'content') and msg.content:
                return msg.content
    return str(result)

Extending the Agent

Add Email Enrichment

def enrich_with_email(profile_url: str) -> dict:
    """Look up email for a LinkedIn profile."""
    # Add your email enrichment logic
    pass

# Add to tools list
self.tools.append(enrich_with_email)

Add Batch Processing

def batch_search(searches: list) -> list:
    """Run multiple searches."""
    results = []
    for search in searches:
        result = search_people(**search)
        results.extend(result["people"])
    return results

Troubleshooting

"CONNECTSAFELY_API_TOKEN not set"

Check your .env file exists
Restart the application after changes

"Google Sheets credentials not found"

Verify OAuth credentials: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_REFRESH_TOKEN
Ensure the JSON file exists

Slow responses

The Gemini API can take 10-30 seconds
Consider using gemini-2.0-flash for faster responses

Resources

Have questions? Drop them in the comments!

Implementing a Job Outreach Agent with AutoGen and ConnectSafely.ai

AMAAN SARFARAZ — Fri, 16 Jan 2026 05:44:18 +0000

Job searching on LinkedIn can be repetitive. You search for jobs, identify companies, research hiring managers, and send connection requests—all manually. What if an AI agent could handle this entire workflow through natural language commands?

This article walks through a technical implementation of an autonomous job search agent built with Microsoft's AutoGen framework and ConnectSafely.ai's LinkedIn API. The agent handles everything from job discovery to sending personalized connection requests, all through conversational commands.

The Problem: Manual LinkedIn Job Search

The typical job search workflow involves several repetitive steps:

Search for jobs matching specific criteria (location, keywords, role)
Extract company information from job listings
Find hiring managers or recruiters at those companies
Check connection status to avoid duplicate requests
Send personalized connection requests
Track and manage responses

Each step requires multiple clicks, page navigations, and manual data entry. For someone applying to 50+ positions, this becomes time-consuming and error-prone.

The Solution: Autonomous Agent with API Access

Instead of manual clicks, we can use an AI agent that:

Understands natural language commands
Maintains context across commands
Orchestrates multiple API calls automatically
Makes intelligent decisions about which tools to use

The key enabler is ConnectSafely.ai, which provides programmatic access to LinkedIn data through a REST API. This eliminates the need for browser automation or unofficial scraping tools.

Architecture Overview

The system consists of three main components:

┌─────────────────────────────────────────────────┐
│          Streamlit Chat Interface               │
│  (Natural language commands from user)          │
└───────────────────┬─────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────┐
│          AutoGen Agent Framework                │
│                                                 │
│  ┌──────────────┐      ┌─────────────────────┐ │
│  │   Assistant  │◄────►│  Memory Manager     │ │
│  │    Agent     │      │  (Job Results)      │ │
│  └──────┬───────┘      └─────────────────────┘ │
│         │                                       │
│         ▼                                       │
│  ┌─────────────────────────────────────────┐   │
│  │         Tool Orchestration              │   │
│  │  (Selects & executes ConnectSafely API) │   │
│  └──────────────────┬──────────────────────┘   │
└───────────────────┬─┴──────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────┐
│          ConnectSafely.ai REST API              │
│                                                 │
│  • Job Search        • Company Details          │
│  • People Search     • Profile Fetch            │
│  • Connection Status • Send Invitations         │
└─────────────────────────────────────────────────┘

Component Breakdown

1. Streamlit Interface (App.py)

A minimal chat interface that handles user input and displays results. The interface maintains session state to preserve conversation history and agent context.

import streamlit as st
from autogen_client import JobSearchClient

def main():
    st.set_page_config(page_title="Job Search Agent", page_icon="💼")

    # Initialize agent once per session
    if "agent_client" not in st.session_state:
        st.session_state.agent_client = JobSearchClient()

    # Handle user commands
    command = st.chat_input("Enter your command...")
    if command:
        result = st.session_state.agent_client.execute(command)
        st.chat_message("assistant").write(result)

2. AutoGen Agent System

The agent system uses AutoGen's AssistantAgent to interpret commands and orchestrate tool execution. It maintains context across multiple commands and stores job results in memory.

3. ConnectSafely.ai API Tools

Seven specialized tools wrap ConnectSafely.ai's REST API endpoints. Each tool handles a specific LinkedIn operation.

ConnectSafely.ai API Integration

ConnectSafely.ai provides a secure, rate-limited REST API for LinkedIn operations. All endpoints use Bearer token authentication.

Authentication Setup

import os
import requests

api_token = os.getenv("CONNECTSAFELY_API_TOKEN")

headers = {
    "Authorization": f"Bearer {api_token}",
    "Content-Type": "application/json"
}

Tool 1: Geographic Location Search

Before searching jobs, we need to convert location names (like "India" or "San Francisco") to LinkedIn's internal location IDs.

def search_geo_location(keywords: str) -> dict:
    """Convert location name to geographic ID.

    Args:
        keywords: Location name (e.g., 'India', 'San Francisco')

    Returns:
        Dict with location_id and location details
    """
    response = requests.post(
        "https://api.connectsafely.ai/linkedin/search/geo",
        headers=headers,
        json={"keywords": keywords},
        timeout=30
    )

    data = response.json()
    # Returns location_id needed for job search
    return {
        "success": True,
        "location_id": data["locations"][0]["id"],
        "location_name": data["locations"][0]["name"]
    }

Example Usage:

result = search_geo_location("Australia")
# Returns: {"location_id": "101452733", "location_name": "Australia"}

Tool 2: Job Search

With a location ID, we can search for jobs by keywords and filters.

def search_jobs(
    location_id: str,
    keywords: str = "software engineer",
    count: int = 5,
    date_posted: str = "past-week"
) -> dict:
    """Search for LinkedIn jobs.

    Args:
        location_id: Geographic location ID (from search_geo_location)
        keywords: Job search keywords
        count: Number of results (max 25)
        date_posted: 'past-24-hours', 'past-week', 'past-month'

    Returns:
        Dict with jobs list containing: jobId, title, companyName, 
        companyId, location, etc.
    """
    payload = {
        "keywords": keywords,
        "count": min(count, 25),
        "filters": {
            "datePosted": date_posted,
            "locationId": location_id
        }
    }

    response = requests.post(
        "https://api.connectsafely.ai/linkedin/search/jobs",
        headers=headers,
        json=payload,
        timeout=30
    )

    data = response.json()
    return {
        "success": True,
        "jobs": data.get("jobs", []),
        "total": data.get("total")
    }

Example Response:

{
  "success": true,
  "jobs": [
    {
      "jobId": "4352695658",
      "title": "Senior Software Engineer",
      "companyName": "TechCorp",
      "companyId": "1234567",
      "location": "Sydney, New South Wales, Australia",
      "postedAt": "2 days ago"
    }
  ],
  "total": 150
}

Tool 3: Finding Hiring Managers

Once we have companies, we can search for hiring managers, recruiters, or other relevant contacts.

def search_hiring_managers(
    company_id: str,
    job_title: str,
    count: int = 3
) -> dict:
    """Find hiring managers at a company.

    Args:
        company_id: LinkedIn company ID
        job_title: Job title to match relevant managers
        count: Number of results

    Returns:
        List of profiles with name, headline, profileId (vanity name)
    """
    # Auto-select appropriate search titles based on role
    title_mapping = {
        "engineer": "Engineering Manager, Tech Lead, Hiring Manager",
        "product": "Product Manager, Head of Product",
        "design": "Design Manager, Head of Design",
        "data": "Data Science Manager, Analytics Manager"
    }

    search_title = next(
        (v for k, v in title_mapping.items() if k in job_title.lower()),
        "Hiring Manager, Recruiter"
    )

    payload = {
        "keywords": search_title,
        "filters": {
            "currentCompany": company_id,
            "connectionDegree": "SECOND"  # 2nd-degree connections
        },
        "count": count
    }

    response = requests.post(
        "https://api.connectsafely.ai/linkedin/search/people",
        headers=headers,
        json=payload,
        timeout=30
    )

    data = response.json()
    return {
        "success": True,
        "managers": data.get("profiles", [])
    }

Key Feature: The tool automatically determines which manager titles to search for based on the job title. For a "Software Engineer" role, it searches for "Engineering Manager" and "Tech Lead" rather than generic "Hiring Manager".

Tool 4: Connection Status Check

Before sending connection requests, check if you're already connected to avoid duplicates.

def check_connection_status(profile_id: str) -> dict:
    """Check connection status with a profile.

    Args:
        profile_id: LinkedIn vanity name (e.g., 'john-doe-123')

    Returns:
        Dict with connection status: 'connected', 'invitationSent', 
        'invitationReceived', or 'not_connected'
    """
    response = requests.get(
        f"https://api.connectsafely.ai/linkedin/relationship/{profile_id}",
        headers=headers,
        timeout=30
    )

    data = response.json()
    return {
        "success": True,
        "status": data.get("connectionDegree", "not_connected"),
        "isConnected": data.get("isConnected", False)
    }

Tool 5: Send Connection Request

Finally, send personalized connection requests with auto-generated messages.

def send_connection_request(
    profile_id: str,
    custom_message: str = None,
    job_title: str = None,
    company_name: str = None
) -> dict:
    """Send connection request with personalized message.

    Args:
        profile_id: LinkedIn vanity name
        custom_message: Optional custom message (300 char limit)
        job_title: Job title for auto-generated message
        company_name: Company name for auto-generated message

    Returns:
        Success status and details
    """
    # Auto-generate message if not provided
    if not custom_message and job_title and company_name:
        custom_message = (
            f"Hi! I noticed the {job_title} role at {company_name} "
            f"and would love to connect. Looking forward to learning more "
            f"about the team and opportunity!"
        )[:300]  # LinkedIn's 300-character limit

    payload = {
        "profileId": profile_id,
        "customMessage": custom_message
    }

    response = requests.post(
        "https://api.connectsafely.ai/linkedin/connect",
        headers=headers,
        json=payload,
        timeout=30
    )

    return {
        "success": response.ok,
        "message": custom_message,
        "profile_url": f"https://linkedin.com/in/{profile_id}"
    }

AutoGen Agent Configuration

The AutoGen agent orchestrates these tools and maintains context between commands.

Agent Factory

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.google import GoogleAIGeminiClient

def create_assistant_agent(tools: list) -> AssistantAgent:
    """Create configured assistant agent with tools."""

    model_client = GoogleAIGeminiClient(
        model="gemini-2.0-flash-exp",
        api_key=os.getenv("GEMINI_API_KEY")
    )

    system_message = """You are a LinkedIn job search assistant.

Available tools:
- search_geo_location: Convert location names to IDs
- search_jobs: Find LinkedIn jobs
- search_hiring_managers: Find recruiters/managers at companies
- check_connection_status: Check if already connected
- send_connection_request: Send personalized requests

Context memory:
- You have access to previous job search results
- Always check connection status before sending requests
- Use job IDs and company IDs from previous searches

Execute commands step by step and provide clear feedback."""

    return AssistantAgent(
        name="job_search_assistant",
        model_client=model_client,
        tools=tools,
        system_message=system_message
    )

Memory Manager

The agent maintains a memory list of job search results that persists across commands.

class MemoryManager:
    """Manages job search results and context."""

    def __init__(self):
        self.job_results = []

    def add_jobs(self, jobs: list):
        """Store job search results."""
        self.job_results.extend(jobs)

    def get_jobs_by_indices(self, indices: list) -> list:
        """Retrieve specific jobs by index."""
        return [
            self.job_results[i] 
            for i in indices 
            if i < len(self.job_results)
        ]

    def get_job_by_id(self, job_id: str) -> dict:
        """Find job by ID."""
        return next(
            (j for j in self.job_results if j.get("jobId") == job_id),
            None
        )

    def clear(self):
        """Reset memory."""
        self.job_results = []

Natural Language Command Processing

The agent processes commands in natural language and determines which tools to use.

Example Workflow

Command 1: "Find 10 software engineering jobs in India"

The agent:

Calls search_geo_location("India") → gets location ID
Calls search_jobs(location_id, "software engineering", count=10)
Stores results in memory
Returns formatted job list

Command 2: "Find hiring managers for the first 3 jobs"

The agent:

Retrieves first 3 jobs from memory
Extracts company IDs
For each company: calls search_hiring_managers(company_id, job_title)
Returns managers with company context

Command 3: "Send connection requests to all managers found"

The agent:

Retrieves managers from previous command
For each manager:
- Calls check_connection_status(profile_id)
- If not connected: calls send_connection_request(profile_id, ...)
Returns success/failure for each request

Code Execution Flow

class JobSearchClient:
    """Client wrapper for agent execution."""

    def __init__(self):
        self.agent = create_assistant_agent(tools)
        self.memory = MemoryManager()

    def execute(self, command: str) -> str:
        """Execute a natural language command.

        Args:
            command: User command (e.g., "Find 5 jobs in Canada")

        Returns:
            Formatted response string
        """
        # Add memory context to command
        context = self._build_context()
        full_prompt = f"{context}\n\nCommand: {command}"

        # Execute via AutoGen
        response = self.agent.run(full_prompt)

        # Update memory if jobs were found
        if "jobs" in response.data:
            self.memory.add_jobs(response.data["jobs"])

        # Format and return response
        return self._format_response(response)

    def _build_context(self) -> str:
        """Build context from memory."""
        if not self.memory.job_results:
            return "No previous results in memory."

        return f"Previous job search: {len(self.memory.job_results)} jobs found"

Installation and Setup

Prerequisites

Python 3.10+
ConnectSafely.ai API token (get yours here)
Google Gemini API key (get here)

Quick Start

# Clone the repository
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples
cd agentic-framework-examples/job-seekers-reach-out-to-hiring-managers/agentic/autogen

# Create .env file
cat > .env << EOF
CONNECTSAFELY_API_TOKEN=your_token_here
GEMINI_API_KEY=your_key_here
EOF

# Install dependencies (using uv)
uv sync

# Run the application
uv run streamlit run App.py

The app will launch at http://localhost:8501

Project Dependencies

[project]
dependencies = [
    "autogen-agentchat>=0.7.0",      # Core AutoGen framework
    "autogen-ext[google]>=0.4.0",    # Google Gemini integration
    "streamlit>=1.39.0",             # Web interface
    "python-dotenv>=1.0.0",          # Environment variables
    "requests>=2.32.0"               # HTTP client
]

Usage Examples

Example 1: Basic Job Search

User: Find 5 backend developer jobs in Canada

Agent Response:
✅ Found 5 backend developer jobs in Canada

1. Senior Backend Engineer - TechCorp (Job ID: 4352695658)
   📍 Toronto, Ontario, Canada
   🕐 Posted 1 day ago

2. Python Backend Developer - StartupXYZ (Job ID: 4352712948)
   📍 Vancouver, British Columbia, Canada
   🕐 Posted 3 days ago

[... 3 more jobs ...]

Example 2: Multi-Step Workflow

User: Find 10 frontend developer jobs in Australia

Agent: ✅ Found 10 jobs

User: Find hiring managers for the first 3 jobs

Agent: ✅ Found hiring managers:

Job #1 (Senior Frontend Engineer at TechCorp):
  • Jane Smith - Engineering Manager
  • Bob Johnson - Tech Lead

Job #2 (React Developer at StartupXYZ):
  • Alice Wong - Head of Engineering

[... etc ...]

User: Send connection requests to all managers

Agent: 
✅ Sent request to Jane Smith (jane-smith-123)
✅ Sent request to Bob Johnson (bob-johnson-456)
⏭️ Already connected with Alice Wong
[... etc ...]

Example 3: Targeted Search

User: Find hiring manager for job ID 4352695658

Agent: 
✅ Found hiring manager for Senior Backend Engineer at TechCorp

Name: Michael Chen
Title: VP of Engineering
Profile: linkedin.com/in/michael-chen-789
Connection: 2nd degree

User: Send connection request to Michael Chen

Agent:
✅ Connection request sent!

Profile: linkedin.com/in/michael-chen-789
Message: "Hi Michael! I noticed the Senior Backend Engineer role at 
TechCorp and would love to connect. Looking forward to learning more 
about the team and opportunity!"

Technical Considerations

Rate Limiting

ConnectSafely.ai implements rate limiting to comply with LinkedIn's terms of service. The agent handles rate limit errors gracefully:

try:
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if response.status_code == 429:
        return {
            "success": False,
            "error": "Rate limit exceeded. Please wait a few minutes."
        }

Error Handling

Each tool implements comprehensive error handling:

def search_jobs(...):
    api_token = os.getenv("CONNECTSAFELY_API_TOKEN")
    if not api_token:
        return {
            "success": False,
            "error": "CONNECTSAFELY_API_TOKEN not set"
        }

    try:
        response = requests.post(...)

        if not response.ok:
            return {
                "success": False,
                "error": f"API error: {response.status_code}"
            }

        return {"success": True, "data": response.json()}

    except Exception as e:
        return {"success": False, "error": str(e)}

Context Management

The agent maintains context with a 2000-character limit to prevent token overflow:

def trim_context(context: str, max_length: int = 2000) -> str:
    """Trim context to prevent token overflow."""
    if len(context) <= max_length:
        return context

    # Keep most recent content
    return "...[earlier context trimmed]\n" + context[-max_length:]

Profile ID Validation

LinkedIn uses "vanity names" for connection requests. The agent validates and extracts these automatically:

def extract_vanity_name(profile_url: str) -> str:
    """Extract vanity name from LinkedIn URL.

    Args:
        profile_url: Full URL like 'https://linkedin.com/in/john-doe-123'

    Returns:
        Vanity name: 'john-doe-123'
    """
    if "linkedin.com/in/" in profile_url:
        return profile_url.split("/in/")[-1].split("/")[0]
    return profile_url

Benefits of This Approach

1. API-Based vs Browser Automation

Traditional Approach (Browser Automation):

Prone to breakage when LinkedIn updates UI
Slow (waits for page loads)
Resource-intensive (runs browser instance)
Risk of account restrictions

API Approach (ConnectSafely.ai):

Stable interface (REST API doesn't change frequently)
Fast (direct HTTP requests)
Lightweight (no browser overhead)
Rate-limited and compliant

2. Natural Language Interface

Users don't need to learn API syntax or write code. Commands like "Find 5 jobs in Canada" are much more intuitive than:

# Without agent
location = search_geo("Canada")
jobs = search_jobs(location["id"], count=5)
for job in jobs:
    company_id = job["companyId"]
    managers = search_people(company_id, ...)
    # ... etc

3. Stateful Conversations

The agent remembers previous results, enabling follow-up commands:

"Find jobs" → stores results
"Find managers for first 3" → uses stored results
"Connect with them" → uses manager list from previous command

4. Intelligent Tool Selection

The agent autonomously decides which tools to use and in what order. For "Find jobs in Australia", it knows to:

First call search_geo_location to get location ID
Then call search_jobs with that ID

Limitations and Future Enhancements

Current Limitations

Single Account: The agent operates with one LinkedIn account at a time
Synchronous Execution: Processes commands sequentially, not in parallel
Basic Personalization: Connection messages use templates, not deep personalization
No Response Tracking: Doesn't track which connections accepted/responded

Potential Enhancements

Response Tracking: Monitor connection acceptances and message replies
Multi-Account Support: Manage campaigns across multiple LinkedIn accounts
Advanced Personalization: Use profile data to craft highly personalized messages
Parallel Processing: Execute multiple API calls concurrently
Scheduling: Schedule connection requests over time to appear more human
Analytics Dashboard: Track success rates, response times, and conversion metrics

Conclusion

This implementation demonstrates how AI agents can automate complex, multi-step workflows through natural language commands. By combining AutoGen's agent orchestration with ConnectSafely.ai's LinkedIn API, we've created a system that handles job search and outreach autonomously while remaining compliant and rate-limited.

The key insights:

API-based automation is more reliable than browser automation
Agent frameworks like AutoGen simplify complex tool orchestration
Natural language interfaces make automation accessible to non-developers
Stateful memory enables multi-step workflows with context preservation

For developers looking to build similar automation tools, the pattern is clear: choose a robust API provider (like ConnectSafely.ai), use an agent framework for orchestration (like AutoGen), and wrap it in a user-friendly interface.

Resources

GitHub Repository: github.com/ConnectSafelyAI/agentic-framework-examples
ConnectSafely.ai Documentation: connectsafely.ai/docs
ConnectSafely.ai Dashboard: connectsafely.ai
AutoGen Documentation: microsoft.github.io/autogen

Connect with ConnectSafely.ai

Stay updated with LinkedIn automation strategies and platform updates:

LinkedIn: linkedin.com/company/connectsafelyai
YouTube: youtube.com/@ConnectSafelyAI-v2x
Instagram: instagram.com/connectsafely.ai
Facebook: facebook.com/connectsafelyai
X (Twitter): x.com/AiConnectsafely

Support

Email: support@connectsafely.ai
Documentation: connectsafely.ai/docs
API Refrence: connectsafely.ai (for API key management)

Have you built automation tools using AI agents? Share your experiences in the comments below!

Building a LinkedIn Job Search Agent with CrewAI and ConnectSafely.ai

AMAAN SARFARAZ — Tue, 13 Jan 2026 13:16:36 +0000

A practical guide to building LinkedIn automation using CrewAI agents and compliant APIs - no scraping, no bans, just clean architecture

Built a LinkedIn job search agent using CrewAI + ConnectSafely.ai that finds jobs, identifies hiring managers, and sends personalized connection requests.

Stack:

🤖 CrewAI (agent framework)
🔗 ConnectSafely.ai (LinkedIn API)
🎨 Streamlit (chat UI)
🐍 Python 3.12

Key approach: One smart agent with multiple tools. No multi-agent complexity. No scraping.

Full code on GitHub 👈

The Problem: Job Hunting is a Manual Nightmare

You know the drill:

Search for jobs on LinkedIn
Open company page
Try to find hiring manager
Check if you're already connected
Craft personalized message
Send connection request
Repeat 50 times

Time per job: 5-10 minutes

Total for 50 jobs: 4-8 hours of soul-crushing clicking

There had to be a better way.

Why CrewAI?

CrewAI is designed for multi-agent systems, but here's the twist: I'm using it with a single agent.

Why?

Multi-agent systems are great for:

Complex role-based workflows
Parallel task execution
Simulating team dynamics

Single agents are better for:

Sequential workflows
Centralized reasoning
Easier debugging
Predictable execution

Job search is inherently sequential: find job → identify company → find manager → check status → send request.

One smart agent > five agents arguing.

Architecture: Keep It Simple

Here's the entire system:

┌─────────────┐
│  Streamlit  │  ← Chat interface
└──────┬──────┘
       │
┌──────▼────────┐
│  CrewAI Agent │  ← Single reasoning agent
└──────┬────────┘
       │
┌──────▼────────────────────────┐
│  Tools (LinkedIn + Jobs)      │
│  via ConnectSafely.ai API     │
└───────────────────────────────┘

Key decisions:

1. Single Agent

Simpler to debug. Maintains context. No coordination overhead.

2. Tool-First Design

Each tool does one thing. Agent orchestrates.

3. API-Driven

No scraping. No browser automation. Just clean API calls.

4. Chat Interface

Natural language commands. Incremental execution.

Setting Up the CrewAI Agent

Here's the complete agent configuration:

# agents/agents.py
from crewai import Agent
from tools import (
    search_jobs_tool,
    get_company_details_tool,
    search_hiring_managers_tool,
    fetch_profile_details_tool,
    check_connection_status_tool,
    send_connection_request_tool,
)

def create_job_outreach_agent():
    """
    Single agent that handles the entire job search workflow
    """
    return Agent(
        role="LinkedIn Job Search Assistant",
        goal=(
            "Help users find relevant jobs, identify hiring managers, "
            "and facilitate meaningful LinkedIn connections"
        ),
        backstory=(
            "You are an expert at job search strategies and LinkedIn networking. "
            "You understand how to identify the right opportunities, find decision-makers, "
            "and craft personalized outreach that gets responses."
        ),
        verbose=True,
        allow_delegation=False,  # Single agent, no delegation
        tools=[
            search_jobs_tool,
            get_company_details_tool,
            search_hiring_managers_tool,
            fetch_profile_details_tool,
            check_connection_status_tool,
            send_connection_request_tool,
        ],
        llm="gemini/gemini-2.0-flash-exp",  # Using Google Gemini
    )

Key parameters:

allow_delegation=False

We don't want this agent delegating to other agents. Keep it simple.

verbose=True

See what the agent is thinking. Critical for debugging.

tools

Explicitly defined. Agent can only use what we give it.

Building the Tools: One Job Each

Each tool wraps a ConnectSafely.ai API endpoint.

Tool #1: Search Jobs

# tools/search_jobs_tool.py
from crewai_tools import tool
import requests
import os

@tool("Search Jobs")
def search_jobs_tool(keyword: str, location: str, limit: int = 25):
    """
    Search for jobs on LinkedIn by keyword and location.

    Args:
        keyword: Job title or keywords (e.g., 'Product Manager', 'Software Engineer')
        location: Geographic location (e.g., 'Bangalore', 'Remote')
        limit: Maximum number of results (default: 25)

    Returns:
        List of job postings with company info
    """
    url = f"{os.getenv('CONNECTSAFELY_API_URL')}/jobs/search"

    response = requests.post(
        url,
        headers={
            "Authorization": f"Bearer {os.getenv('CONNECTSAFELY_API_KEY')}",
            "Content-Type": "application/json",
        },
        json={
            "keyword": keyword,
            "location": location,
            "limit": limit,
        }
    )

    if not response.ok:
        return {"error": f"Job search failed: {response.status_text}"}

    data = response.json()

    return {
        "total": data.get("total", 0),
        "jobs": [
            {
                "id": job["id"],
                "title": job["title"],
                "company": job["company"],
                "company_id": job["companyId"],
                "location": job["location"],
                "posted_date": job["postedDate"],
                "url": job["jobUrl"],
            }
            for job in data.get("results", [])
        ]
    }

Design decisions:

Explicit docstring:

CrewAI uses docstrings to help the agent understand what tools do.

Structured output:

Return clean, typed data the agent can reason about.

Error handling:

Don't crash - return error objects the agent can handle.

Tool #2: Find Hiring Managers

# tools/search_hiring_managers_tool.py
from crewai_tools import tool
import requests
import os

@tool("Search Hiring Managers")
def search_hiring_managers_tool(company_id: str, job_title: str = None):
    """
    Find hiring managers and recruiters at a specific company.

    Args:
        company_id: LinkedIn company ID
        job_title: Optional filter (e.g., 'Recruiter', 'Engineering Manager')

    Returns:
        List of people who might be hiring managers
    """
    url = f"{os.getenv('CONNECTSAFELY_API_URL')}/companies/{company_id}/people"

    params = {}
    if job_title:
        params["jobTitle"] = job_title

    response = requests.get(
        url,
        headers={
            "Authorization": f"Bearer {os.getenv('CONNECTSAFELY_API_KEY')}",
        },
        params=params
    )

    if not response.ok:
        return {"error": f"Failed to find hiring managers: {response.status_text}"}

    data = response.json()

    return {
        "company_id": company_id,
        "company_name": data.get("companyName"),
        "people": [
            {
                "id": person["id"],
                "name": person["name"],
                "headline": person["headline"],
                "profile_url": person["publicProfileUrl"],
            }
            for person in data.get("results", [])
        ]
    }

Tool #3: Check Connection Status (THE CRITICAL ONE)

This is the most important tool. Never skip this.

# tools/check_connection_status_tool.py
from crewai_tools import tool
import requests
import os

@tool("Check Connection Status")
def check_connection_status_tool(profile_id: str):
    """
    Check if you're already connected to someone on LinkedIn.

    ALWAYS use this before sending connection requests to avoid spam.

    Args:
        profile_id: LinkedIn profile ID or public identifier

    Returns:
        Connection status information
    """
    url = f"{os.getenv('CONNECTSAFELY_API_URL')}/connections/status/{profile_id}"

    response = requests.get(
        url,
        headers={
            "Authorization": f"Bearer {os.getenv('CONNECTSAFELY_API_KEY')}",
        }
    )

    if not response.ok:
        return {"error": f"Status check failed: {response.status_text}"}

    data = response.json()

    return {
        "profile_id": profile_id,
        "is_connected": data.get("connected", False),
        "connection_degree": data.get("degree"),  # 1st, 2nd, 3rd
        "pending_request": data.get("pending", False),
        "can_connect": data.get("canConnect", False),
    }

Why this matters:

✅ Prevents spam
✅ Avoids LinkedIn penalties
✅ Respects people's time
✅ Saves API credits

Tool #4: Send Connection Request

# tools/send_connection_request_tool.py
from crewai_tools import tool
import requests
import os

@tool("Send Connection Request")
def send_connection_request_tool(profile_id: str, message: str = None):
    """
    Send a personalized LinkedIn connection request.

    Args:
        profile_id: LinkedIn profile ID
        message: Optional personalized note (max 300 characters)

    Returns:
        Success status and request details
    """
    # Validate message length
    if message and len(message) > 300:
        return {
            "error": f"Message too long: {len(message)} characters (max 300)"
        }

    url = f"{os.getenv('CONNECTSAFELY_API_URL')}/connections/send"

    response = requests.post(
        url,
        headers={
            "Authorization": f"Bearer {os.getenv('CONNECTSAFELY_API_KEY')}",
            "Content-Type": "application/json",
        },
        json={
            "profileId": profile_id,
            "message": message,
        }
    )

    if not response.ok:
        return {"error": f"Connection request failed: {response.status_text}"}

    data = response.json()

    return {
        "success": True,
        "profile_id": profile_id,
        "request_id": data.get("invitationId"),
        "sent_at": data.get("timestamp"),
    }

Wiring It Together: The Crew

# crew.py
from crewai import Crew, Task, Process
from agents.agents import create_job_outreach_agent

def create_job_search_crew():
    """
    Create a CrewAI crew with a single agent
    """
    agent = create_job_outreach_agent()

    return Crew(
        agents=[agent],
        tasks=[],  # Tasks are created dynamically via chat
        process=Process.sequential,
        verbose=True,
    )

# Initialize crew
crew = create_job_search_crew()

def execute_command(user_input: str):
    """
    Execute a user command via the agent
    """
    # Create a dynamic task from user input
    task = Task(
        description=user_input,
        agent=crew.agents[0],
        expected_output="Completion status and results"
    )

    # Execute
    result = crew.kickoff(tasks=[task])

    return result

Key points:

Dynamic tasks:

Instead of pre-defined workflows, we create tasks on-the-fly from user commands.

Sequential process:

Tasks execute one at a time, maintaining context.

Single agent:

Even though CrewAI supports multi-agent, we keep it simple.

The Streamlit Chat Interface

# App.py
import streamlit as st
from crew import execute_command

st.title("🤖 LinkedIn Job Search Assistant")
st.caption("Powered by CrewAI + ConnectSafely.ai")

# Initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []

# Display chat history
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Chat input
if prompt := st.chat_input("What would you like to do?"):
    # Add user message
    st.session_state.messages.append({"role": "user", "content": prompt})

    with st.chat_message("user"):
        st.markdown(prompt)

    # Get agent response
    with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
            response = execute_command(prompt)
            st.markdown(response)

    # Add assistant message
    st.session_state.messages.append({
        "role": "assistant",
        "content": response
    })

Why Streamlit?

Quick to build
Chat-style interface
State management built-in
Good for prototyping

A Real Workflow in Action

Here's what happens when you use this system:

You: Find product manager jobs in Bangalore

Agent: 🔍 Searching for jobs...
       Found 35 Product Manager positions in Bangalore

You: Show me the top 3 companies

Agent: Here are the top 3:
       1. Flipkart (Senior PM - Payments)
       2. Razorpay (Product Manager - Growth)
       3. PhonePe (Lead Product Manager)

You: Find hiring managers at Razorpay

Agent: 🔎 Searching Razorpay employees...
       Found 12 people in product/recruiting roles:
       - Sarah Kumar (Head of Product)
       - Amit Patel (Senior Recruiter)
       - Priya Sharma (Product Manager)

You: Check if I'm connected to Sarah Kumar

Agent: ✓ Checking connection status...
       Status: Not connected (2nd degree)
       Can send request: Yes
       Mutual connections: 3

You: Send her a connection request about the PM role

Agent: ✅ Crafting personalized message...
       ✅ Sent connection request to Sarah Kumar
       Message: "Hi Sarah, I noticed Razorpay is hiring for a 
       Product Manager - Growth role. With my background in fintech 
       and growth product management, I'd love to connect and learn 
       more about the opportunity."

Total time: ~2 minutes

Manual equivalent: 30-45 minutes

Why ConnectSafely.ai Makes This Possible

Let's be honest: scraping LinkedIn is a terrible idea.

I know this because I tried it first. Built a beautiful Puppeteer script that worked for 4 days before:

LinkedIn changed their DOM structure
Everything broke
My account got flagged
I wasted a week

The scraping approach:

# ❌ Don't do this

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://linkedin.com/jobs")

# Wait for selectors that change weekly
jobs = driver.find_elements_by_class_name("job-card-xyz")

# Pray nothing breaks
for job in jobs:
    job.click()

The ConnectSafely approach:

# ✅ Do this instead

response = requests.post(
    f"{API_URL}/jobs/search",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"keyword": "Product Manager", "location": "Bangalore"}
)

jobs = response.json()

Benefits:

✅ Stable API endpoints

✅ No DOM parsing

✅ Structured responses

✅ Rate limiting built-in

✅ Compliance guaranteed

✅ No account bans

One API call vs 50 lines of fragile automation.

Environment Setup

# .env
GOOGLE_API_KEY=your_google_api_key
CONNECTSAFELY_API_KEY=your_connectsafely_api_key
CONNECTSAFELY_API_URL=https://api.connectsafely.ai/v1

Dependencies (pyproject.toml):

[project]
name = "linkedin-job-agent"
version = "0.1.0"
requires-python = ">=3.12"

dependencies = [
    "crewai>=0.86.0",
    "streamlit>=1.40.2",
    "requests>=2.32.3",
    "python-dotenv>=1.0.1",
]

Install with uv:

# Install uv (fast Python package manager)
pip install uv

# Create virtual environment and install dependencies
uv sync

# Run the app
uv run streamlit run App.py

Try It Yourself

Ready to build your own?

# Clone the repo
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples
cd job-seekers-reach-out-to-hiring-managers/agentic/crewai

# Install dependencies
uv sync

# Set up environment
cp .env.example .env
# Add your API keys

# Run
uv run streamlit run App.py

Get API Access:

Sign up at connectsafely.ai
Get your API key from dashboard
Read the docs

Resources & Support

📂 Code: GitHub - CrewAI

📚 Documentation:

💬 Support:

Email: support@connectsafely.ai
Docs: connectsafely.ai/docs

🌐 Connect:
LinkedIn • YouTube • Instagram • Facebook • X

Building something cool with CrewAI? Drop a comment—I'd love to see what you're working on!

Questions about the architecture? Hit me up. Always happy to nerd out about agent design patterns. 🤓

Want to see this built with other frameworks? Check out the repo—we've got Mastra and LangGraph versions too!

Building a LinkedIn Outreach Agent with LangGraph and ConnectSafely.ai

AMAAN SARFARAZ — Tue, 13 Jan 2026 06:00:43 +0000

A production-style agentic workflow for LinkedIn outreach using LangGraph state machines and ConnectSafely.ai API

This article walks through building a production-grade agentic workflow using LangGraph and ConnectSafely.ai for LinkedIn outreach automation.

The goal: help job seekers identify relevant jobs, discover hiring managers, and perform controlled LinkedIn outreach—without browser automation, scraping, or UI hacking.

Core Design Principles

✅ Explicit state transitions

✅ Deterministic tools

✅ Strict separation between reasoning and execution

✅ No prompt hacks or brittle automation

System Architecture Overview

This isn't a free-running autonomous loop. It's a graph-based agent where LangGraph controls execution flow and ConnectSafely.ai enforces safety boundaries.

LangGraph State Machine
├─ Search jobs
├─ Resolve company details
├─ Find hiring managers
├─ Fetch LinkedIn profile data
├─ Check connection status
└─ Send connection request
    ↓
ConnectSafely.ai API
    ↓
LinkedIn Platform

LangGraph controls what happens next.

ConnectSafely.ai controls what is allowed to happen.

Why LangGraph Over Simple Agent Loops?

LangGraph is used because this workflow is stateful and conditional.

Each step:

Consumes structured state
Produces structured output
Decides the next transition deterministically

This approach:

✅ Avoids prompt-driven branching
✅ Makes execution traceable
✅ Enables debugging and replay
✅ Prevents infinite loops

Project Structure

├── index.ts                    # Entry point
├── agents/
│   └── job-search-outreach-agent.ts  # LangGraph state machine
├── tools/                      # LinkedIn API wrappers
│   ├── searchJobs.ts
│   ├── getCompanyDetails.ts
│   ├── searchHiringManagers.ts
│   ├── fetchProfileDetails.ts
│   ├── checkConnectionStatus.ts
│   └── sendConnectionRequest.ts
├── cli/                        # Interactive CLI
└── .env                        # API keys

Runtime Stack

TypeScript for type safety
Bun for fast startup and dependency management
LangGraph for workflow orchestration
ConnectSafely.ai for LinkedIn API access

Entry Point

// index.ts
import { runCli } from "./cli";

runCli();

Simple, clean, and framework-agnostic.

The Agent Definition

The core logic lives in agents/job-search-outreach-agent.ts:

import { StateGraph } from "@langchain/langgraph";

const graph = new StateGraph<AgentState>()
  .addNode("searchJobs", searchJobs)
  .addNode("getCompanyDetails", getCompanyDetails)
  .addNode("searchHiringManagers", searchHiringManagers)
  .addNode("fetchProfileDetails", fetchProfileDetails)
  .addNode("checkConnectionStatus", checkConnectionStatus)
  .addNode("sendConnectionRequest", sendConnectionRequest)
  .addEdge("searchJobs", "getCompanyDetails")
  .addEdge("getCompanyDetails", "searchHiringManagers")
  .addEdge("searchHiringManagers", "fetchProfileDetails")
  .addEdge("fetchProfileDetails", "checkConnectionStatus")
  .addConditionalEdges("checkConnectionStatus", routingLogic);

Each node is a pure function over state. No side effects, no hidden behavior.

Tool Design: Deterministic by Construction

All LinkedIn-facing logic is implemented as tools. Each tool:

✅ Has a single responsibility
✅ Performs one API call
✅ Returns structured data
✅ Never makes decisions

This keeps the agent layer clean and testable.

1️⃣ Searching Jobs

export async function searchJobs(input: {
  keyword: string;
  location: string;
}) {
  const response = await fetch(`${API_URL}/linkedin/search/jobs`, {
    headers: {
      Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify(input)
  });

  return response.json();
}

The agent decides when to search.

The tool only executes.

2️⃣ Fetching Company Details

export async function getCompanyDetails(input: {
  companyId: string;
}) {
  const response = await fetch(
    `${API_URL}/linkedin/search/companies/details`,
    {
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`
      }
    }
  );

  return response.json();
}

No scraping. No HTML parsing. Only structured responses.

3️⃣ Finding Hiring Managers

export async function searchHiringManagers(input: {
  companyId: string;
}) {
  const response = await fetch(
    `${API_URL}/linkedin/search/hiring-managers`,
    {
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`
      }
    }
  );

  return response.json();
}

The agent receives candidates directly—no guessing or scraping required.

4️⃣ Fetching Profile Details

export async function fetchProfileDetails(input: {
  profileId: string;
}) {
  const response = await fetch(
    `${API_URL}/linkedin/profile/details`,
    {
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`
      }
    }
  );

  return response.json();
}

This data is used for:

✅ Validation
✅ Personalization
✅ Rule-based decisions

5️⃣ Connection Safety Checks

Before any outreach, the system verifies connection state:

export async function checkConnectionStatus(input: {
  profileId: string;
}) {
  const response = await fetch(
    `${API_URL}/linkedin/connections/status`,
    {
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`
      }
    }
  );

  return response.json();
}

This prevents:

❌ Duplicate requests
❌ Invalid actions
❌ Noisy automation

LangGraph uses this output to decide the next edge.

6️⃣ Sending Connection Requests

Only after passing all checks does the workflow reach execution:

export async function sendConnectionRequest(input: {
  profileId: string;
  note?: string;
}) {
  const response = await fetch(
    `${API_URL}/linkedin/connections/send`,
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(input)
    }
  );

  return response.json();
}

The agent cannot bypass platform rules—those are enforced by ConnectSafely.ai.

ConnectSafely.ai as the Execution Boundary

This system does not:

❌ Run headless browsers

❌ Scrape LinkedIn pages

❌ Manage cookies or sessions

❌ Simulate human behavior

Instead:

✅ All LinkedIn actions are API calls

✅ Authentication is key-based

✅ Rate limits and safety rules are enforced externally

✅ Platform complexity is isolated

The agent stays clean and portable.

CLI Interface

The cli/ directory provides:

# Interactive execution
$ bun run start

# Command routing
$ bun run agent --job "Software Engineer" --location "San Francisco"

# State visualization
$ bun run agent --debug

This makes the workflow usable without modifying code and helps with debugging graph transitions.

State Management Example

interface AgentState {
  // User inputs
  jobKeyword: string;
  location: string;

  // Job search results
  jobs: Job[];
  selectedJob?: Job;

  // Company context
  company?: Company;

  // Hiring managers
  hiringManagers: Profile[];
  selectedManager?: Profile;

  // Connection state
  connectionStatus?: ConnectionStatus;

  // Execution tracking
  currentStep: string;
  errors: string[];
}

State flows through the graph explicitly—no hidden context.

Conditional Routing Logic

function routingLogic(state: AgentState): string {
  const { connectionStatus } = state;

  if (connectionStatus === "ALREADY_CONNECTED") {
    return "skipConnectionRequest";
  }

  if (connectionStatus === "PENDING") {
    return "skipConnectionRequest";
  }

  if (connectionStatus === "CAN_CONNECT") {
    return "sendConnectionRequest";
  }

  return "end";
}

Decision logic is explicit, testable, and debuggable.

Why This Architecture Works

This pattern scales because:

✅ Reasoning is explicit — no hidden prompt logic

✅ Execution is deterministic — same input = same path

✅ State is visible — full observability

✅ Platform risk is externalized — LinkedIn complexity isolated

Ideal Use Cases

🎯 Recruiting workflows
🔍 Job discovery automation
📊 CRM enrichment
⚖️ Compliance-sensitive LinkedIn tooling
🤝 B2B outreach campaigns

Key Takeaways

LangGraph is ideal for multi-step, stateful agents
Agents should orchestrate, not improvise
LinkedIn automation belongs behind an API boundary
Deterministic tools beat prompt-only logic
Safety checks must be first-class nodes

Get Started

Prerequisites

# Install Bun
curl -fsSL https://bun.sh/install | bash

# Clone the repository
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples/tree/main/job-seekers-reach-out-to-hiring-managers/agentic/langGraph

# Install dependencies
bun install

# Set up environment variables
cp .env.example .env
# Add your ConnectSafely.ai API key

Running the Agent

# Interactive mode
bun run start

# Direct execution
bun run agent --job "Product Manager" --location "Remote"

Resources & Documentation

Official Documentation

Support

Email: support@connectsafely.ai
Documentation: connectsafely.ai/docs
Api Refrence: connectsafely.ai (API key management)

Connect With Us

What's Next?

This architecture can be extended to:

Multi-channel outreach (email + LinkedIn)
CRM integration (sync to Salesforce, HubSpot)
Advanced personalization with LLMs
Analytics and campaign tracking
Team collaboration features

Want to build your own agentic workflows? Start with LangGraph and ConnectSafely.ai.

Building reliable AI automation requires architecture, not just prompts. This is what production-grade agents look like.

Have questions or want to share your implementation? Drop a comment below! 👇

Building a LinkedIn Outreach Agent with ConnectSafely.ai and Mastra

AMAAN SARFARAZ — Tue, 13 Jan 2026 05:34:32 +0000

A deep dive into building production-ready LinkedIn automation using deterministic agents, clean tool abstractions, and API-first architecture

Built a LinkedIn job search automation agent that finds jobs, identifies hiring managers, and sends connection requests—without scraping, browser automation, or getting banned.

Stack:

🤖 Mastra (agent orchestration)
🔗 ConnectSafely.ai (LinkedIn API)
⚡ TypeScript + Bun

Key principle: Agents orchestrate, APIs execute, tools stay dumb.

Full code on GitHub 👈

The Problem: LinkedIn Automation That Doesn't Suck

You want to automate LinkedIn outreach. You have three options:

Option 1: Scraping + Selenium

Breaks every UI update
Gets your account banned
Maintenance nightmare

Option 2: Sketchy Chrome Extensions

Security risks
Limited functionality
Still risk account bans

Option 3: Build It Right

API-driven
Compliant
Actually maintainable

This article is about Option 3.

Architecture: Keep It Stupid Simple

Here's the entire system in one diagram:

User Query
    ↓
Mastra Agent (orchestration)
    ↓
Tools (execution)
    ├─ Search jobs
    ├─ Resolve company
    ├─ Find hiring managers
    ├─ Fetch profile data
    ├─ Check connection status
    └─ Send connection request
    ↓
ConnectSafely.ai API (platform access)
    ↓
LinkedIn (the actual platform)

Key insight: The agent never touches LinkedIn directly. All platform operations go through ConnectSafely.ai.

Why this matters:

No scraping = no bans
API changes are handled upstream
You write business logic, not LinkedIn reverse-engineering

What is Mastra?

Mastra is an agent framework, but it's not trying to simulate AGI or build an autonomous AI assistant.

What it does:

Provides structured agent definitions
Handles tool orchestration
Manages execution flow
Keeps things deterministic

What it doesn't do:

Run infinite loops
Make unpredictable decisions
Hide what's happening
Try to be "too smart"

Think of it as glue code with an LLM brain—the LLM decides what to do, but the tools define how to do it.

Agent Setup: Explicit Over Clever

Here's how you define an agent in Mastra:

import { createAgent } from "@mastra/core";
import { searchJobs } from "../tools/search-jobs";
import { searchHiringManagers } from "../tools/search-hiring-managers";
import { fetchProfileDetails } from "../tools/fetch-profile";
import { checkConnectionStatus } from "../tools/check-connection";
import { sendConnectionRequest } from "../tools/send-connection";

export const jobOutreachAgent = createAgent({
  name: "job-search-outreach-agent",

  instructions: `
    You help users find relevant jobs and connect with hiring managers on LinkedIn.

    Workflow:
    1. Search for jobs based on user criteria
    2. Get company details for each job
    3. Find hiring managers at those companies
    4. Fetch profile details to personalize outreach
    5. Check connection status before sending requests
    6. Send personalized connection requests

    Always verify connection status before attempting to connect.
    Never send duplicate requests.
  `,

  tools: [
    searchJobs,
    searchHiringManagers,
    fetchProfileDetails,
    checkConnectionStatus,
    sendConnectionRequest,
  ],
});

What makes this powerful:

1. Fixed Instructions

No prompt injection. No hallucinated workflows. The agent knows its job.

2. Explicit Tool Set

You control exactly what the agent can do. No surprise API calls.

3. Clear Workflow

The sequence is documented and predictable.

4. Debuggable

When something breaks, you know which tool failed.

Tool Design: One Job, One Tool

Each tool is a single-purpose function that wraps a ConnectSafely.ai API call.

Tool #1: Search Jobs

import { createTool } from "@mastra/core";

export const searchJobs = createTool({
  id: "search-jobs",
  description: "Search for jobs on LinkedIn by keyword and location",

  inputSchema: {
    keyword: {
      type: "string",
      description: "Job title or keywords (e.g., 'Software Engineer', 'Product Manager')",
    },
    location: {
      type: "string",
      description: "Location (e.g., 'San Francisco, CA', 'Remote')",
    },
    limit: {
      type: "number",
      description: "Maximum number of results (default: 25)",
      optional: true,
    },
  },

  execute: async ({ context }) => {
    const { keyword, location, limit = 25 } = context;

    const response = await fetch(
      `${process.env.CONNECTSAFELY_API_URL}/jobs/search`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ keyword, location, limit }),
      }
    );

    if (!response.ok) {
      throw new Error(`Job search failed: ${response.statusText}`);
    }

    return response.json();
  },
});

Design principles:

Clear Interface

Input schema is explicitly defined. No guessing.

Single Responsibility

This tool only searches jobs. Nothing else.

Error Handling

Failures are explicit, not silent.

No Business Logic

The tool executes. The agent decides when to execute.

Tool #2: Find Hiring Managers

export const searchHiringManagers = createTool({
  id: "search-hiring-managers",
  description: "Find hiring managers and recruiters at a specific company",

  inputSchema: {
    companyId: {
      type: "string",
      description: "LinkedIn company ID",
    },
    jobTitle: {
      type: "string",
      description: "Filter by job title (e.g., 'Recruiter', 'Engineering Manager')",
      optional: true,
    },
  },

  execute: async ({ context }) => {
    const { companyId, jobTitle } = context;

    const url = new URL(
      `${process.env.CONNECTSAFELY_API_URL}/companies/${companyId}/people`
    );

    if (jobTitle) {
      url.searchParams.append("jobTitle", jobTitle);
    }

    const response = await fetch(url.toString(), {
      headers: {
        Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
      },
    });

    if (!response.ok) {
      throw new Error(`Failed to find hiring managers: ${response.statusText}`);
    }

    const data = await response.json();

    // Return structured data the agent can work with
    return {
      companyId,
      managers: data.people.map((person: any) => ({
        profileId: person.id,
        name: person.name,
        title: person.headline,
        profileUrl: person.profileUrl,
      })),
    };
  },
});

Why this structure?

Separation of Concerns

Agent: "I need hiring managers for this company"
Tool: "Here's how to get them from the API"
ConnectSafely: "Here's the actual data"

No Scraping Logic

Notice what's not in this code:

❌ DOM selectors
❌ Browser automation
❌ Cookie management
❌ Session handling

Just clean API calls.

Tool #3: Fetch Profile Details

export const fetchProfileDetails = createTool({
  id: "fetch-profile-details",
  description: "Get detailed information about a LinkedIn profile",

  inputSchema: {
    profileId: {
      type: "string",
      description: "LinkedIn profile ID or vanity URL",
    },
  },

  execute: async ({ context }) => {
    const { profileId } = context;

    const response = await fetch(
      `${process.env.CONNECTSAFELY_API_URL}/profiles/${profileId}`,
      {
        headers: {
          Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
        },
      }
    );

    if (!response.ok) {
      throw new Error(`Failed to fetch profile: ${response.statusText}`);
    }

    const profile = await response.json();

    return {
      id: profile.id,
      name: profile.name,
      headline: profile.headline,
      location: profile.location,
      about: profile.about,
      experience: profile.experience,
      skills: profile.skills,
      profileUrl: profile.profileUrl,
    };
  },
});

What this enables:

Personalization

You can craft messages based on actual profile data.

Validation

Check if the person matches your ICP before reaching out.

Rule-Based Filtering

"Only connect with people who have 5+ years experience in X"

Tool #4: Check Connection Status (CRITICAL)

This is the most important tool. Never skip this step.

export const checkConnectionStatus = createTool({
  id: "check-connection-status",
  description: "Check if you're already connected to someone on LinkedIn",

  inputSchema: {
    profileId: {
      type: "string",
      description: "LinkedIn profile ID",
    },
  },

  execute: async ({ context }) => {
    const { profileId } = context;

    const response = await fetch(
      `${process.env.CONNECTSAFELY_API_URL}/connections/status/${profileId}`,
      {
        headers: {
          Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
        },
      }
    );

    if (!response.ok) {
      throw new Error(`Failed to check connection status: ${response.statusText}`);
    }

    const status = await response.json();

    return {
      profileId,
      isConnected: status.connected,
      connectionLevel: status.level, // 1st, 2nd, 3rd, etc.
      pendingRequest: status.pending,
      canConnect: status.canConnect,
    };
  },
});

Why this matters:

Prevents Duplicates

Don't send connection requests to people you're already connected to.

Avoids Policy Violations

LinkedIn has rules about connection spam. This keeps you compliant.

Saves Credits

Most LinkedIn automation tools charge per action. Don't waste them.

Better UX

Respect people's time. Don't send redundant requests.

Tool #5: Send Connection Request

The final step—actual outreach.

export const sendConnectionRequest = createTool({
  id: "send-connection-request",
  description: "Send a personalized connection request on LinkedIn",

  inputSchema: {
    profileId: {
      type: "string",
      description: "LinkedIn profile ID",
    },
    note: {
      type: "string",
      description: "Personalized message (max 300 characters)",
      optional: true,
    },
  },

  execute: async ({ context }) => {
    const { profileId, note } = context;

    // Validation: Check note length
    if (note && note.length > 300) {
      throw new Error("Connection note must be 300 characters or less");
    }

    const response = await fetch(
      `${process.env.CONNECTSAFELY_API_URL}/connections/send`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.CONNECTSAFELY_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          profileId,
          note: note || undefined,
        }),
      }
    );

    if (!response.ok) {
      throw new Error(`Failed to send connection request: ${response.statusText}`);
    }

    const result = await response.json();

    return {
      success: true,
      profileId,
      sentAt: result.timestamp,
      messageId: result.id,
    };
  },
});

Key safeguards:

Validation at Tool Level

Character limits are enforced before the API call.

Clear Error Messages

If something fails, you know why.

Audit Trail

Returns message IDs for tracking and debugging.

Rate Limiting Delegated

ConnectSafely.ai handles rate limits. You don't.

Why ConnectSafely.ai is the Right Abstraction

Let's be clear about what this system does not do:

❌ Use headless browsers (Puppeteer, Playwright)

❌ Scrape DOM elements

❌ Manage cookies or sessions

❌ Simulate user behavior

❌ Reverse-engineer LinkedIn's private APIs

❌ Risk your account with ToS violations

Instead:

✅ LinkedIn actions are clean API calls

✅ Authentication is key-based (no password handling)

✅ Rate limits are enforced externally

✅ Platform logic is isolated from your code

✅ Compliance is built-in

This keeps your agent:

Portable — Runs anywhere, no browser dependencies
Safe — No account ban risks
Maintainable — API changes are handled upstream
Scalable — No Selenium overhead

Why this matters:

Idempotency

Running the agent twice doesn't send duplicate requests.

Resume from Failure

If the agent crashes mid-workflow, pick up where it left off.

Audit Trail

Know exactly what the agent did and when.

Cost Efficiency

Don't re-process jobs or profiles you've already handled.

The Complete Workflow in Action

Here's what happens when a user asks: "Find software engineering jobs in San Francisco and connect me with hiring managers"

Step 1: Agent Reasoning

// Agent receives the query
const response = await jobOutreachAgent.run({
  messages: [
    {
      role: "user",
      content: "Find software engineering jobs in San Francisco and connect me with hiring managers",
    },
  ],
});

The agent's LLM brain parses this and decides:

Need to search jobs first
Then find hiring managers for each job
Check connection status
Send personalized requests

Step 2: Tool Execution Sequence

// 1. Search for jobs
const jobs = await searchJobs.execute({
  keyword: "Software Engineer",
  location: "San Francisco, CA",
  limit: 10,
});

// 2. For each job, find hiring managers
for (const job of jobs.results) {
  // Skip if already processed
  if (hasProcessedJob(job.id)) {
    continue;
  }

  // Find people at this company
  const managers = await searchHiringManagers.execute({
    companyId: job.companyId,
    jobTitle: "Recruiter",
  });

  // 3. For each hiring manager
  for (const manager of managers.managers) {
    // Check if already contacted
    if (hasContactedProfile(manager.profileId)) {
      console.log(`Already contacted ${manager.name}`);
      continue;
    }

    // 4. Check connection status
    const status = await checkConnectionStatus.execute({
      profileId: manager.profileId,
    });

    if (status.isConnected) {
      console.log(`Already connected to ${manager.name}`);
      continue;
    }

    if (!status.canConnect) {
      console.log(`Cannot connect to ${manager.name} (likely 3rd+ degree)`);
      continue;
    }

    if (status.pendingRequest) {
      console.log(`Already sent request to ${manager.name}`);
      continue;
    }

    // 5. Fetch profile for personalization
    const profile = await fetchProfileDetails.execute({
      profileId: manager.profileId,
    });

    // 6. Send personalized connection request
    const note = `Hi ${profile.name.split(" ")[0]}, I saw you're hiring for ${job.title} at ${job.company}. I'd love to connect and learn more about the role!`;

    const result = await sendConnectionRequest.execute({
      profileId: manager.profileId,
      note,
    });

    // 7. Track the attempt
    trackConnectionAttempt(manager.profileId, result.success);

    console.log(`✅ Sent connection request to ${manager.name}`);

    // Rate limiting: wait between requests
    await new Promise((resolve) => setTimeout(resolve, 2000));
  }

  // Mark job as processed
  markJobProcessed(job.id);
}

Output:

🔍 Found 10 software engineering jobs in San Francisco
👥 Found 24 hiring managers across companies

Processing "Senior Software Engineer" at Stripe...
  ✅ Sent connection request to Sarah Johnson (Recruiter)
  ⏭️  Already connected to Mike Chen (Engineering Manager)

Processing "Backend Engineer" at Airbnb...
  ✅ Sent connection request to Alex Rivera (Technical Recruiter)
  ⏭️  Already sent request to Jessica Wang (Hiring Manager)

Processing "Full Stack Developer" at Uber...
  ⚠️  Cannot connect to David Kim (3rd+ degree connection)
  ✅ Sent connection request to Emily Zhang (Talent Acquisition)

Summary:
- Jobs analyzed: 10
- Hiring managers found: 24
- Connection requests sent: 5
- Already connected: 3
- Pending requests: 2
- Cannot connect: 1

Runtime and Environment

Tech stack choices:

TypeScript

Type safety for tools and agent config
Better IDE support
Easier refactoring

Bun

Fast runtime (10x faster than Node for some tasks)
Built-in TypeScript support
Native SQLite bindings
Great developer experience

.env Configuration

# .env
CONNECTSAFELY_API_KEY=your_api_key_here
CONNECTSAFELY_API_URL=https://api.connectsafely.ai/v1
DATABASE_PATH=./mastra.db
MAX_JOBS_PER_RUN=20
MAX_CONNECTIONS_PER_JOB=5

No Framework Lock-in

The agent code is portable:

Swap Mastra for another framework
Replace SQLite with Postgres
Deploy to any Node/Bun environment

Why This Pattern Scales

This architecture works because it's built on solid principles:

1. Separation of Concerns

Agent (Reasoning)

Decides what to do
Sequences operations
Handles errors

Tools (Execution)

Implement one action
Return structured data
Stay deterministic

ConnectSafely (Platform)

Manages LinkedIn access
Enforces rate limits
Handles compliance

2. Deterministic Tools Beat "Smart" Prompts

// ❌ Prompt-based approach (unpredictable)
const result = await llm.chat([
  { role: "system", content: "You are a LinkedIn automation expert" },
  { role: "user", content: "Search for jobs and send connection requests" }
]);

// ✅ Tool-based approach (deterministic)
const jobs = await searchJobs.execute({ keyword, location });
const managers = await searchHiringManagers.execute({ companyId });
await sendConnectionRequest.execute({ profileId, note });

3. Platform Risk is Externalized

Your responsibility:

Business logic
Workflow sequencing
Data processing

ConnectSafely's responsibility:

LinkedIn API compliance
Rate limiting
Account safety
Platform updates

4. Workflows are Explicit

No hidden magic. No emergent behavior. Just clear, traceable execution.

Applying This Pattern to Other Use Cases

The same architecture works for:

CRM Enrichment

const crmAgent = createAgent({
  name: "crm-enricher",
  tools: [
    fetchCompanyData,
    enrichContactInfo,
    updateCrmRecord,
  ],
});

Recruiting Pipelines

const recruitingAgent = createAgent({
  name: "candidate-sourcer",
  tools: [
    searchCandidates,
    assessSkillMatch,
    sendOutreach,
    trackResponses,
  ],
});

Sales Prospecting

const prospectingAgent = createAgent({
  name: "lead-generator",
  tools: [
    findCompanies,
    identifyDecisionMakers,
    enrichLeadData,
    queueOutreach,
  ],
});

Compliance-Heavy Automations

const complianceAgent = createAgent({
  name: "compliant-outreach",
  tools: [
    checkConsentStatus,
    validateDataPrivacy,
    logAuditTrail,
    sendMessage,
  ],
});

Key Takeaways

If you remember nothing else, remember these principles:

1. Agents Should Orchestrate, Not Improvise

Give your agent clear instructions and good tools. Don't ask it to be creative with platform interactions.

2. Platform Access Belongs Behind an API

Never scrape what you can API. ConnectSafely.ai handles LinkedIn so you don't have to.

3. Deterministic Tools Beat "Smart" Prompts

A well-designed tool with clear inputs/outputs is more reliable than prompting an LLM to figure it out.

4. State Management is Mandatory

Track what you've done. Idempotency isn't optional for production agents.

5. Debuggability Matters More Than Autonomy

You'll spend 80% of your time debugging. Make it easy.

Try It Yourself

Want to build your own LinkedIn automation agent?

Quick Start

# Clone the repo
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples/tree/main/job-seekers-reach-out-to-hiring-managers/agentic/mastra

# Install dependencies
bun install

# Set up environment
cp .env.example .env
# Add your ConnectSafely API key

# Run it
bun run dev

Get API Access

Sign up at connectsafely.ai
Get your API key from the dashboard
Read the docs

Resources & Support

📂 Code: GitHub - Mastra Examples

📚 Documentation:

💬 Support:

Email: support@connectsafely.ai
Documentation: connectsafely.ai/docs

🌐 Connect:
LinkedIn • YouTube • Instagram • Facebook • X

Building something cool with agents? Drop a comment—I'd love to see what you're working on!

Questions about the architecture? Hit me up. Always happy to nerd out about agent design patterns. 🤓

Building a LinkedIn Lead Gen Agent That Actually Works

AMAAN SARFARAZ — Mon, 12 Jan 2026 06:24:35 +0000

How I built an AI agent to extract premium LinkedIn members using Agno and ConnectSafely.ai - with real code, real numbers, and lessons learned the hard way

Built an AI agent that extracts LinkedIn Premium members from groups in ~90 seconds. No scraping, no browser automation, no account bans. Using Agno (agent framework) + ConnectSafely.ai (compliant LinkedIn API).

Full code on GitHub 👈

The Problem: I Wasted 6 Hours Clicking LinkedIn Profiles

You know that feeling when you need to find decision-makers in a LinkedIn group, and you end up clicking through profiles one by one like it's 2005?

Yeah. That was me last month.

I needed to extract all Premium/Verified members from a 5,000-person LinkedIn group. For context, these are usually:

Founders with actual budgets
VPs who can say "yes" to deals
Verified professionals investing in their careers

Manual approach: 6 hours of clicking → 47 contacts → severe mouse fatigue → existential crisis about my career choices

What I needed:

Auto-fetch thousands of members ✅
Identify Premium/Verified badges ✅
Filter out noise ✅
Export to Google Sheets ✅
Not get my LinkedIn account banned ✅✅✅

Spoiler: I built it. Let me show you how.

Why Not Just Scrape It?

Short answer: Because I like my LinkedIn account.

Long answer: I tried the "scraping route" first. Here's what happened:

Scraping is a technical dead end for LinkedIn automation:

Selectors break with every UI update
Rate limiting is aggressive and unpredictable
Account bans are permanent
Legal gray area (or just illegal)

There had to be a better way.

The Stack: Agno + ConnectSafely.ai

After burning a week on dead ends, I landed on this architecture:

🤖 Agno: AI agent framework
🔗 ConnectSafely.ai: LinkedIn automation API (compliant, stable, actually works)

📊 Google Sheets API: For export and CRM integration

Why Agno?

Most agent frameworks want you to build elaborate multi-agent systems with "Product Manager Agent," "Engineer Agent," "QA Agent" all chatting via prompts.

Cool for demos. Terrible for production.

Agno is different:

One agent that orchestrates tools
Explicit workflows (no emergent behavior)
Tool-first design (agent is the glue, not the worker)

Think of it as hiring one senior dev instead of managing a committee of junior agents.

Why ConnectSafely.ai?

Because I don't want to:

Reverse-engineer LinkedIn's private APIs
Manage session cookies and CSRF tokens
Handle rate limiting logic
Debug why profiles stopped loading
Get banned

ConnectSafely gives me:

# This just works™
members = connectsafely.fetch_group_members(group_id)

No scraping. No browser automation. Just data.

Architecture: Keep It Stupid Simple

Here's the folder structure:

agentic/agno/
├── app.py                     # Entry point
├── agents/
│   └── agent.py               # Agno agent config
│
├── config/
│   ├── agent_setup.py         
│   ├── workflows.py           
│   └── constants.py           
│
├── tools/
│   ├── linkedin/
│   │   ├── fetch_group_members_tool.py
│   │   ├── filter_premium_tool.py
│   │   └── workflow_tool.py
│   │
│   └── googlesheet/
│       ├── sheets_tool.py
│       └── export_tool.py
│
└── README.md

Design principle: Each tool does ONE thing. No god classes. No hidden coupling.

The Agent: Configured Once, Used Forever

Here's the agent setup:

from agno import Agent
from agno.llms import Gemini

agent = Agent(
    name="LinkedInPremiumExtractor",
    description=(
        "You extract LinkedIn group members via ConnectSafely.ai, "
        "filter for Premium/Verified users, and export to Google Sheets. "
        "You are precise, efficient, and never scrape."
    ),
    llm=Gemini(model="gemini-3-pro-preview"),
    tools=[
        fetch_group_members_tool,
        filter_premium_verified_tool,
        export_to_sheets_tool,
    ],
    show_tool_calls=True,  # Debug mode
    markdown=True,
)

What makes this work:

Agent knows exactly what success looks like
Tools are explicitly listed (no discovery overhead)
LLM is used for orchestration only (not data processing)
One agent, zero delegation chaos

Tool #1: Fetch Members (The Right Way)

from connectsafely import ConnectSafelyClient

def fetch_group_members_tool(group_id: str) -> list:
    """
    Fetch all members from a LinkedIn group.
    Handles pagination automatically.
    """
    client = ConnectSafelyClient(api_key=os.getenv("CONNECTSAFELY_API_KEY"))

    response = client.groups.fetch_members(
        group_id=group_id,
        pagination=True,
        include_badges=True,  # We need Premium/Verified status
        timeout=30
    )

    return response.members

What this handles automatically:

✅ Pagination for group members
✅ Rate limiting (respects LinkedIn's limits)
✅ Retries on network failures
✅ Session management

What I don't have to worry about:

❌ CSS selectors
❌ Browser fingerprinting
❌ Cookie management
❌ Getting banned

Tool #2: Filter Premium Members

This tool isolates the filtering logic:

def filter_premium_verified_tool(members: list) -> list:
    """
    Filter members to only Premium/Verified accounts.
    """
    filtered = []

    for member in members:
        is_premium = member.get("isPremium", False)
        is_verified = member.get("isVerified", False)
        has_badge = "premium" in member.get("badges", [])

        if is_premium or is_verified or has_badge:
            filtered.append(member)

    return filtered

Why isolate this?

Easy to test in isolation
Reusable across workflows
Simple to extend (add location, industry filters)
Clear single responsibility

Want to filter by geography?

if member.get("location") == "San Francisco, CA":
    filtered.append(member)

Done.

Tool #3: Export to Google Sheets

Final step: getting data into a usable format.

from googleapiclient.discovery import build

def export_to_sheets_tool(members: list, sheet_id: str):
    """
    Export filtered members to Google Sheets.
    """
    service = build('sheets', 'v4', credentials=creds)

    # Prepare data
    rows = [["Name", "Headline", "Profile URL", "Status", "Company"]]

    for m in members:
        rows.append([
            m.get("name", "N/A"),
            m.get("headline", "N/A"),
            m.get("profileUrl", "N/A"),
            "Premium" if m.get("isPremium") else "Verified",
            m.get("company", "N/A"),
        ])

    # Write to sheet
    service.spreadsheets().values().update(
        spreadsheetId=sheet_id,
        range="Sheet1!A1",
        valueInputOption="RAW",
        body={"values": rows}
    ).execute()

    return {"status": "success", "rows": len(rows)}

Output is CRM-ready:

Clean column headers
No manual formatting needed
Direct import to HubSpot/Salesforce

The Workflow: No Black Box Magic

Here's the beautiful part—the workflow is explicit:

def run_extraction_workflow(group_id: str, sheet_id: str):
    # Step 1: Fetch all members
    print("Fetching members...")
    members = fetch_group_members_tool(group_id)
    print(f"✅ Fetched {len(members)} members")

    # Step 2: Filter Premium/Verified
    print("Filtering for Premium/Verified...")
    premium = filter_premium_verified_tool(members)
    print(f"✅ Found {len(premium)} Premium/Verified members")

    # Step 3: Export to Sheets
    print("Exporting to Google Sheets...")
    result = export_to_sheets_tool(premium, sheet_id)
    print(f"✅ Exported {result['rows']} rows")

    return result

No hidden agent chatter.

No task confusion.

Just execution.

You can read the code and know exactly what happens. Try doing that with 5 LLM agents delegating tasks via prompts.

Real Numbers: Production Performance

From actual production runs:

┌─────────────────────────────────────┐
│ Performance Metrics                 │
├─────────────────────────────────────┤
│ Extraction Speed:  ~50 members/sec  │
│ Accuracy:          98% detection    │
│ Max Group Size:    10,000+ members  │
│ API Uptime:        99.9%            │
└─────────────────────────────────────┘

Example run:

$ uv run streamlit run App.py

Fetching members...
✅ Fetched 3,847 members (76s)

Filtering for Premium/Verified...
✅ Found 412 Premium/Verified members (10.7% conversion)

Exporting to Google Sheets...
✅ Exported 413 rows (4s)

Total time: 80 seconds

That's 412 high-quality leads in under 90 seconds.

Manual approach? 6-8 hours of soul-crushing clicking.

Lessons Learned (The Hard Way)

✅ What Worked

1. Single Agent > Agent Swarm

One agent with good tools beats 5 agents arguing via prompts.

2. APIs > Scraping (Always)

Scraping is technical debt from day one. APIs scale.

3. Tool Isolation = Easy Debugging

When tools do one thing, debugging is trivial. When they're coupled, it's hell.

🔧 What Was Painful

1. Google OAuth Dance

Refresh tokens, scopes, service accounts... took longer than the actual agent code.

2. Agent Prompts Matter More Than You Think

Vague description = vague results. Be surgical with your agent's purpose.

3. Large Groups Need Chunking

5k members? You'll hit memory limits. Process in batches.

🐛 Bugs I Hit (So You Don't Have To)

# Bug 1: Forgot to handle missing badges
# Fix: Use .get() with defaults
badges = member.get("badges", [])

# Bug 2: Rate limits on Sheets API
# Fix: Batch updates, don't write row-by-row
service.spreadsheets().values().batchUpdate(...)

# Bug 3: Agent hallucinating tool parameters
# Fix: Use Pydantic models for strict typing
class FetchMembersInput(BaseModel):
    group_id: str = Field(..., description="LinkedIn group ID")

What's Next: Future Roadmap

Planning these upgrades:

# 🔄 CRM Sync
def sync_to_hubspot(members: list):
    # Direct HubSpot/Salesforce integration
    pass

# 🔔 Real-time Monitoring
def watch_new_premium_members(group_id: str):
    # Webhook alerts for new Premium joins
    pass

# 📦 Batch Processing
def process_multiple_groups(group_ids: list):
    # Analyze 10+ groups in parallel
    pass

# 🧠 AI Lead Scoring
def score_leads(members: list):
    # Rank prospects by profile content
    pass

Real-World Use Cases

This is already being used by:

Sales teams: Targeting enterprise decision-makers
Recruiters: Sourcing verified engineers/designers
Marketers: Building ABM target lists
Founders: Partnership research and networking
Event organizers: Finding keynote speakers

Try It Yourself

Want to build your own version?

📂 GitHub: ConnectSafelyAI/agentic-framework-examples

📚 Docs: connectsafely.ai/docs

🔑 API Keys: https://connectsafely.ai/docs/api

Quick Start

# Clone the repo
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples
cd extract-linkedin-premium-users-from-linkedin-groups/agentic/agno

# Install dependencies
uv sync

# Set up environment
cp .env.example .env
# Add your ConnectSafely API key

# Run it
uv run streamlit run App.py

Resources & Support

📧 Email: support@connectsafely.ai

📖 Documentation: connectsafely.ai/docs

💼 Custom Workflows: Contact for enterprise automation

Follow us for more automation tips:

LinkedIn • YouTube • Instagram • Facebook • X • Bluesky • Mastodon

Key Takeaways

Agent ≠ Complexity: One smart agent beats agent sprawl
Tools > Prompts: Give your agent good tools, not good vibes
APIs > Scraping: Always. No exceptions.
Compliance Matters: Build systems you can actually run in production

Building something cool with AI agents? Drop it in the comments—I'd love to see what you're working on!

Hit me up if you have questions or want to chat about agent architectures. Always down to nerd out about this stuff. 🤓

Building a Multi-Agent LinkedIn Automation System

AMAAN SARFARAZ — Tue, 06 Jan 2026 09:52:43 +0000

Step-by-Step Guide to Creating AI Agents for Lead Extraction

This tutorial shows you how to build a production-ready AI agent system that extracts Premium LinkedIn members from groups. We'll use CrewAI for agent orchestration and ConnectSafely.ai for safe LinkedIn access.

What You'll Build: A system that processes 5,000 LinkedIn members in 2 minutes vs 10+ hours manually

Source Code: https://github.com/ConnectSafelyAI/agentic-framework-examples/tree/main/extract-linkedin-premium-users-from-linkedin-groups/agentic/crewai

Prerequisites

Before starting, you'll need:

Python 3.10 or higher installed
Basic understanding of APIs and Python
ConnectSafely.ai API access (free trial available)
Google Gemini API key for the AI agents

Part 1: Understanding the Architecture

Our system uses three specialized AI agents:

Researcher Agent handles LinkedIn data fetching

Analyst Agent filters for premium members

Manager Agent exports to Google Sheets

Each agent communicates through CrewAI's orchestration layer, creating a pipeline where output from one agent feeds into the next.

Part 2: Project Setup

Create your project directory and install dependencies:

mkdir linkedin-extractor
cd linkedin-extractor

Install uv package manager (faster than pip):

curl -LsSf https://astral.sh/uv/install.sh | sh

Initialize the project:

uv init

Add required dependencies to pyproject.toml:

[project]
name = "linkedin-extractor"
version = "0.1.0"
dependencies = [
    "crewai>=0.28.0",
    "streamlit>=1.28.0",
    "requests>=2.31.0",
    "google-auth>=2.23.0",
    "google-api-python-client>=2.100.0",
]

Install everything:

uv sync

Part 3: Setting Up ConnectSafely.ai

Why use ConnectSafely.ai instead of building your own scraper?

Handles LinkedIn rate limits automatically
Prevents account bans
Returns rich profile data
Saves weeks of development time

Create .env file in your project root:

CONNECTSAFELY_API_TOKEN=your_token_here
GEMINI_API_KEY=your_gemini_key_here

Part 4: Building the Fetch Tool

Create tools/fetch_tool.py:

import os
import requests
from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class FetchInput(BaseModel):
    group_id: str = Field(description="LinkedIn group ID")
    max_members: int = Field(default=None, description="Max to fetch")

class LinkedInFetchTool(BaseTool):
    name: str = "LinkedIn Group Fetcher"
    description: str = "Fetches members from LinkedIn groups via ConnectSafely.ai"
    args_schema = FetchInput

    def _run(self, group_id: str, max_members: int = None):
        token = os.getenv("CONNECTSAFELY_API_TOKEN")
        url = "https://api.connectsafely.ai/linkedin/groups/members"

        all_members = []
        offset = 0

        while True:
            response = requests.post(
                url,
                headers={"Authorization": f"Bearer {token}"},
                json={"groupId": group_id, "start": offset, "count": 50}
            )

            data = response.json()
            batch = data.get("members", [])
            all_members.extend(batch)

            # Check if we should continue
            if not data.get("hasMore") or (max_members and len(all_members) >= max_members):
                break

            offset += 50

        # Trim to max if specified
        if max_members:
            all_members = all_members[:max_members]

        return {
            "success": True,
            "members": all_members,
            "count": len(all_members)
        }

Key Points:

Automatic pagination with offset tracking
Respects max_members limit
Returns structured data for next agent

Part 5: Creating the Filter Tool

Create tools/filter_tool.py:

from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class FilterInput(BaseModel):
    members: list = Field(description="List of members to filter")

class PremiumFilterTool(BaseTool):
    name: str = "Premium Member Filter"
    description: str = "Identifies Premium and Verified LinkedIn members"
    args_schema = FilterInput

    def _run(self, members: list):
        premium_list = []

        for person in members:
            badges = person.get("badges", [])

            # Check multiple premium indicators
            is_premium = (
                person.get("isPremium") or
                person.get("isVerified") or
                any("premium" in str(b).lower() for b in badges) or
                any("verified" in str(b).lower() for b in badges)
            )

            if is_premium:
                premium_list.append(person)

        return {
            "success": True,
            "premium_members": premium_list,
            "premium_count": len(premium_list),
            "original_count": len(members),
            "premium_rate": round(len(premium_list) / len(members) * 100, 2)
        }

Why Multiple Criteria?

LinkedIn indicates premium status in several ways:

Direct isPremium boolean flag
Verified account status
Premium badges in profile
Verification badges

Checking all ensures we don't miss valuable leads.

Part 6: Building the Agents

Create agents/linkedin_agents.py:

import os
from crewai import Agent, LLM
from tools.fetch_tool import LinkedInFetchTool
from tools.filter_tool import PremiumFilterTool

class LinkedInAgents:
    def __init__(self):
        self.llm = LLM(
            model="gemini/gemini-3-pro-preview",
            temperature=0.7,
            api_key=os.getenv("GEMINI_API_KEY")
        )

    def researcher(self):
        return Agent(
            role="LinkedIn Researcher",
            goal="Extract all members from specified LinkedIn groups",
            backstory="Expert at using ConnectSafely.ai to gather LinkedIn data efficiently",
            tools=[LinkedInFetchTool()],
            llm=self.llm,
            verbose=True,
            allow_delegation=False
        )

    def analyst(self):
        return Agent(
            role="Data Analyst",
            goal="Identify premium and verified LinkedIn members",
            backstory="Specialist in analyzing LinkedIn profiles for premium indicators",
            tools=[PremiumFilterTool()],
            llm=self.llm,
            verbose=True,
            allow_delegation=False
        )

Agent Configuration Tips:

Set allow_delegation=False to keep agents focused
Use temperature 0.7 for balanced responses
Provide clear, specific backstories

Part 7: Creating Tasks

Create tasks/tasks.py:

from crewai import Task

def create_fetch_task(agent, group_id, max_members=None):
    description = f"""
    Fetch all members from LinkedIn group {group_id}.
    Use the LinkedIn Group Fetcher tool.
    {f'Limit to {max_members} members.' if max_members else 'Fetch all available.'}
    """

    expected_output = """
    Return JSON with:
    - success: boolean
    - members: array of member objects
    - count: total number fetched
    """

    return Task(
        description=description,
        expected_output=expected_output,
        agent=agent
    )

def create_filter_task(agent, context):
    description = """
    Analyze the member list and identify Premium/Verified accounts.
    Use the Premium Member Filter tool with the members from the previous task.
    """

    expected_output = """
    Return JSON with:
    - success: boolean
    - premium_members: array of premium member objects
    - premium_count: number of premium members found
    - premium_rate: percentage of premium members
    """

    return Task(
        description=description,
        expected_output=expected_output,
        agent=agent,
        context=context
    )

Tasks define what each agent should accomplish and what output format to use.

Part 8: Orchestrating the Workflow

Create workflow.py:

from crewai import Crew, Process
from agents.linkedin_agents import LinkedInAgents
from tasks.tasks import create_fetch_task, create_filter_task

class ExtractionWorkflow:
    def __init__(self):
        self.agents = LinkedInAgents()

    def run(self, group_id, max_members=None):
        # Create agents
        researcher = self.agents.researcher()
        analyst = self.agents.analyst()

        # Create tasks with dependencies
        task1 = create_fetch_task(researcher, group_id, max_members)
        task2 = create_filter_task(analyst, context=[task1])

        # Execute workflow
        crew = Crew(
            agents=[researcher, analyst],
            tasks=[task1, task2],
            process=Process.sequential,
            verbose=True
        )

        result = crew.kickoff()
        return result

The workflow executes tasks sequentially, passing data between agents.

Part 9: Building the UI

Create app.py with Streamlit:

import streamlit as st
from workflow import ExtractionWorkflow

st.set_page_config(page_title="LinkedIn Extractor", layout="wide")

st.title("LinkedIn Premium Member Extractor")
st.write("Extract and filter premium members from LinkedIn groups")

with st.sidebar:
    st.header("Configuration")
    group_id = st.text_input("LinkedIn Group ID")
    max_members = st.number_input("Max Members", 100, 10000, 1000)

if st.button("Start Extraction"):
    if not group_id:
        st.error("Please enter a group ID")
    else:
        with st.spinner("Processing..."):
            workflow = ExtractionWorkflow()
            result = workflow.run(group_id, max_members)
            st.success("Complete!")
            st.json(result)

Part 10: Running Your System

Start the application:

uv run streamlit run app.py

Navigate to http://localhost:8501 in your browser.

Testing:

Enter a LinkedIn group ID
Set max members (start with 100 for testing)
Click "Start Extraction"
Watch the agents work!

Part 11: Performance Optimization

Add caching for repeated requests:

from functools import lru_cache

@lru_cache(maxsize=100)
def cached_fetch(group_id, max_members):
    return LinkedInFetchTool()._run(group_id, max_members)

Add progress tracking:

import streamlit as st

progress_bar = st.progress(0)
status_text = st.empty()

# Update during processing
progress_bar.progress(50)
status_text.text("Filtering premium members...")

Part 12: Error Handling

Add robust error handling to your tools:

def _run(self, group_id: str, max_members: int = None):
    try:
        token = os.getenv("CONNECTSAFELY_API_TOKEN")
        if not token:
            return {"success": False, "error": "Missing API token"}

        # API call here
        response = requests.post(url, headers=headers, timeout=30)

        if not response.ok:
            return {"success": False, "error": f"API error {response.status_code}"}

        return {"success": True, "data": response.json()}

    except requests.Timeout:
        return {"success": False, "error": "Request timed out"}
    except Exception as e:
        return {"success": False, "error": str(e)}

Part 13: Testing Your Agents

Create tests/test_tools.py:

import pytest
from tools.fetch_tool import LinkedInFetchTool

def test_fetch_returns_members():
    tool = LinkedInFetchTool()
    result = tool._run("test_group_id", max_members=10)

    assert result["success"] == True
    assert "members" in result
    assert result["count"] <= 10

Run tests:

uv run pytest tests/

Part 14: Real-World Results

After implementing this system, here's what we achieved:

Tech Community Group (1,523 members)

Premium found: 287 (18.8%)
Processing time: 31 seconds
Manual time saved: 3 hours

Marketing Professionals (3,847 members)

Premium found: 412 (10.7%)
Processing time: 76 seconds
Manual time saved: 8 hours

Accuracy: 98% precision with zero false positives

Part 15: Deployment Options

Deploy with Docker:

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install uv && uv sync
EXPOSE 8501
CMD ["uv", "run", "streamlit", "run", "app.py"]

Build and run:

docker build -t linkedin-extractor .
docker run -p 8501:8501 linkedin-extractor

Common Issues and Solutions

Issue: API token not found

Solution: Ensure .env file is in project root and properly formatted

Issue: Slow processing

Solution: Reduce batch size or implement parallel processing

Issue: Missing premium members

Solution: Check all premium criteria are being evaluated

Next Steps

Enhance your system with:

Google Sheets export integration
CRM synchronization (Salesforce, HubSpot)
Webhook notifications for new members
Advanced filtering with custom rules
Batch processing for multiple groups

Resources

Documentation:

ConnectSafely.ai Docs: https://connectsafely.ai/docs
API Reference: https://connectsafely.ai/docs/api
n8n Integration: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.code/

Support:

Email: support@connectsafely.ai
LinkedIn: https://linkedin.com/company/connectsafelyai
YouTube: https://youtube.com/@ConnectSafelyAI-v2x

Community:

Twitter: https://x.com/AiConnectsafely
Instagram: https://instagram.com/connectsafely.ai
Bluesky: https://connectsafelyai.bsky.social
Facebook: https://facebook.com/people/ConnectSafelyAI/61582550884724/
Mastodon: https://mastodon.social/@connectsafely

Questions about the implementation? Drop them in the comments!

Building a LinkedIn Premium Member Extractor Agent with ConnectSafely.ai and LangGraph

AMAAN SARFARAZ — Fri, 26 Dec 2025 18:19:10 +0000

Learn how to build an intelligent LinkedIn automation agent using ConnectSafely.ai's API and LangGraph. Extract premium members from any LinkedIn group and export them to Google Sheets—all with natural language commands.

🚀 Why This Matters

LinkedIn automation is notoriously difficult. The platform actively blocks scraping tools, and building reliable automation requires:

✅ Handling LinkedIn's complex authentication
✅ Managing rate limits and pagination
✅ Avoiding detection and bans
✅ Maintaining stable API connections

Enter ConnectSafely.ai - a LinkedIn automation platform that handles all of this complexity for you. In this tutorial, we'll combine ConnectSafely.ai's robust API with LangGraph's agentic workflow framework to build something powerful: an AI agent that understands natural language and executes complex LinkedIn workflows autonomously.

🎯 What We're Building

An intelligent agent that can:

You: "Extract 50 premium members from LinkedIn group 9357376 and save them to a Google Sheet titled 'Premium Leads'"

Agent: ✓ Fetched 50 members from group 9357376
        ✓ Filtered 23 premium/verified members
        ✓ Saved to Google Sheet: https://docs.google.com/spreadsheets/d/...

Live Demo: GitHub Repository

🛠️ Tech Stack

ConnectSafely.ai - LinkedIn automation API (the core enabler)
LangGraph - Agentic workflow framework
Google Gemini - LLM for agent intelligence
Google Sheets API - Data persistence
Bun - Fast JavaScript runtime

📋 Prerequisites

ConnectSafely.ai Account (Most Important!)
- Sign up at connectsafely.ai
- Get your API token from the dashboard
- This is what makes the entire automation possible
Google Cloud Project (for Gemini + Sheets)
- Enable Gemini API
- Set up Google Sheets OAuth
Bun installed

   curl -fsSL https://bun.sh/install | bash

🎬 Part 1: Understanding ConnectSafely.ai

ConnectSafely.ai is the backbone of this project. It provides a simple REST API that abstracts away all LinkedIn complexity.

Why ConnectSafely.ai?

Without ConnectSafely.ai:

// ❌ Complex LinkedIn scraping
- Handle cookies and sessions
- Solve CAPTCHAs
- Manage proxy rotation
- Deal with account bans
- Parse HTML manually
- Handle rate limits

With ConnectSafely.ai:

// ✅ Simple API call
const response = await fetch('https://api.connectsafely.ai/linkedin/groups/members', {
  method: 'POST',
  headers: { Authorization: `Bearer ${CONNECTSAFELY_API_TOKEN}` },
  body: JSON.stringify({ groupId: '12345', start: 0, count: 50 })
});

ConnectSafely.ai Features We'll Use:

Group Members Extraction
- Fetch members from any LinkedIn group
- Automatic pagination
- Rich profile data (premium status, verification, badges)
Premium Member Detection
- Identifies LinkedIn Premium subscribers
- Filters verified accounts
- Extracts profile badges
Reliable & Fast
- Built-in rate limit handling
- Automatic retries
- Enterprise-grade infrastructure

🏗️ Part 2: Project Architecture

┌─────────────────┐
│  User Query     │
│  (Natural Lang) │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────┐
│   LangGraph Agent           │
│   (Powered by Gemini)       │
└────────┬────────────────────┘
         │
         ├──────────────────────┐
         ▼                      ▼
┌──────────────────┐   ┌──────────────────┐
│ ConnectSafely.ai │   │  Google Sheets   │
│    LinkedIn API  │   │       API        │
└──────────────────┘   └──────────────────┘
         │                      │
         ▼                      ▼
    [Members Data]        [Saved to Sheet]

Key Insight: ConnectSafely.ai handles the hardest part (LinkedIn automation), while LangGraph orchestrates the workflow.

💻 Part 3: Implementation

Step 1: Clone the Repository

git clone https://github.com/ConnectSafelyAI/agentic-framework-examples.git
cd agentic-framework-examples/extract-linkedin-premium-users-from-linkedin-groups/agentic/langGraph

Step 2: Install Dependencies

bun install

Step 3: Configure Environment

cp .env.example .env

Edit .env:

# 🔑 MOST IMPORTANT - Get this from ConnectSafely.ai dashboard
CONNECTSAFELY_API_TOKEN=your_connectsafely_token_here

# Google Gemini API (for the AI agent)
GOOGLE_API_KEY=your_gemini_key

# Google OAuth (for Sheets)
GOOGLE_CLIENT_ID=your_client_id
GOOGLE_CLIENT_SECRET=your_client_secret
GOOGLE_REFRESH_TOKEN=your_refresh_token

Step 4: Understanding the ConnectSafely.ai Integration

File: tools/linkedin/complete-group-members-workflow.ts

import { tool } from "@langchain/core/tools";
import { z } from "zod";

const CONNECTSAFELY_API_TOKEN = process.env.CONNECTSAFELY_API_TOKEN;

export const completeGroupMembersWorkflowTool = tool(
  async ({ groupId, maxMembers }) => {
    // ConnectSafely.ai handles all the LinkedIn complexity
    const response = await fetch(
      "https://api.connectsafely.ai/linkedin/groups/members",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${CONNECTSAFELY_API_TOKEN}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ 
          groupId, 
          start: 0, 
          count: 50 
        }),
      }
    );

    const data = await response.json();

    // Filter for premium members
    const premiumMembers = data.members.filter(m => 
      m.isPremium || m.isVerified || m.badges?.includes('premium')
    );

    return JSON.stringify({
      totalFetched: data.members.length,
      totalFiltered: premiumMembers.length,
      members: premiumMembers
    });
  },
  {
    name: "complete-group-members-workflow",
    description: "Fetch LinkedIn group members and filter for Premium/Verified profiles using ConnectSafely.ai",
    schema: z.object({
      groupId: z.string(),
      maxMembers: z.number().optional(),
    }),
  }
);

What's happening:

✅ ConnectSafely.ai handles LinkedIn authentication
✅ ConnectSafely.ai fetches group members
✅ ConnectSafely.ai provides rich profile data
✅ We simply filter the results

🤖 Part 4: The LangGraph Agent

File: agents/linkedin-group-members-fetcher-agent.ts

import { StateGraph, END, START } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { AgentState } from "../tools/types/index.js";
import { linkedInTools } from "../tools/linkedin/index.js";
import { googleSheetsTool } from "../tools/googlesheet/index.js";

// Combine all tools
const allTools = [...linkedInTools, googleSheetsTool];

// Initialize Gemini LLM
const model = new ChatGoogleGenerativeAI({
  model: "gemini-2.0-flash-exp",
  temperature: 0,
}).bindTools(allTools);

// System prompt - teaches the agent how to use ConnectSafely.ai tools
const SYSTEM_PROMPT = `You are a LinkedIn automation agent powered by ConnectSafely.ai.

Available tools:
1. complete-group-members-workflow - Uses ConnectSafely.ai to fetch and filter members
2. google-sheets - Saves members to Google Sheets

When user asks to "extract premium members and save to sheets":
1. Call complete-group-members-workflow (ConnectSafely.ai handles the extraction)
2. Call google-sheets with the results
`;

// Create the StateGraph workflow
export function createLinkedInAgent() {
  const workflow = new StateGraph(AgentState)
    .addNode("agent", callModel)
    .addNode("tools", new ToolNode(allTools))
    .addEdge(START, "agent")
    .addConditionalEdges("agent", shouldContinue)
    .addEdge("tools", "agent");

  return workflow.compile();
}

The Magic: LangGraph orchestrates, ConnectSafely.ai executes!

🎮 Part 5: Running the Agent

Interactive Mode (Chat with the Agent)

bun start

Example Session:

╔════════════════════════════════════════════════════════════╗
║  LinkedIn Premium Members Agent (Powered by ConnectSafely) ║
╚════════════════════════════════════════════════════════════╝

You: Extract 100 premium members from group 9357376

🤖 Agent: Working on it...

✓ Using ConnectSafely.ai to fetch members from group 9357376
✓ Fetched 100 members
✓ Filtered 42 premium/verified members

You: Save them to a Google Sheet titled "Premium Leads Dec 2024"

🤖 Agent: Creating spreadsheet...

✓ Created spreadsheet: https://docs.google.com/spreadsheets/d/abc123
✓ Added 42 members to sheet

You: exit

One-Shot Mode (Single Command)

bun start "Extract 50 premium members from group 9357376 and save to Google Sheets"

🔍 Part 6: How ConnectSafely.ai Makes This Possible

Let's compare what this would look like without ConnectSafely.ai:

Without ConnectSafely.ai ❌

// You'd need to:
1. Reverse-engineer LinkedIn's API
2. Handle authentication flows
3. Manage cookies and sessions
4. Solve CAPTCHAs programmatically
5. Rotate proxies to avoid bans
6. Parse HTML responses
7. Handle rate limits manually
8. Deal with account restrictions
9. Maintain the scraper as LinkedIn changes

= Weeks/months of development + constant maintenance

With ConnectSafely.ai ✅

// Simple API call:
const members = await fetch('https://api.connectsafely.ai/linkedin/groups/members', {
  headers: { Authorization: `Bearer ${token}` },
  body: JSON.stringify({ groupId: '12345' })
});

= 5 lines of code, enterprise-ready

📊 Real-World Use Cases

1. Lead Generation

You: "Extract all premium members from the 'B2B SaaS Founders' group and save to sheets"

→ Instant qualified lead list

2. Competitor Analysis

You: "Get premium members from group 555 and group 666, combine them"

→ Identify key players in your industry

3. Community Building

You: "Extract verified members from 5 different AI/ML groups"

→ Find potential community members

4. Recruitment

You: "Get premium members with 'CTO' or 'Engineering Manager' in headline from group 12345"

→ Targeted recruitment pipeline

🎯 Advanced Features

Custom Filters

ConnectSafely.ai returns rich profile data. You can filter on:

const premiumMembers = members.filter(m => {
  return m.isPremium &&                    // Premium subscriber
         m.isVerified &&                    // Verified account
         m.followerCount > 1000 &&          // Influential
         m.headline?.includes('Founder');   // Specific role
});

Batch Processing

Process multiple groups:

const groupIds = ['111', '222', '333'];

for (const groupId of groupIds) {
  const members = await fetchFromConnectSafely(groupId);
  // Process each group
}

Smart Deduplication

The Google Sheets tool automatically:

✅ Detects duplicate Profile IDs
✅ Skips existing members
✅ Only adds new records

🚨 Common Issues & Solutions

Issue 1: "Failed to fetch members"

❌ Error: Failed to fetch members: 401 Unauthorized

Solution: Check your ConnectSafely.ai API token

# Verify token is set
echo $CONNECTSAFELY_API_TOKEN

# Get new token from connectsafely.ai dashboard

Issue 2: "No premium members found"

✓ Fetched 100 members
✓ Filtered 0 premium members

Solution: The group might not have premium members, or try a larger sample:

You: "Extract 500 members from group 12345"

📈 Performance & Scalability

ConnectSafely.ai Performance:

⚡ Speed: 50 members fetched in ~2-3 seconds
📊 Reliability: 99.9% uptime
🔄 Rate Limits: Handled automatically
🌍 Global: Works from anywhere

Scaling Tips:

For Small Groups (< 500 members):

   You: "Extract all premium members from group 12345"

For Large Groups (> 1000 members):

   You: "Extract premium members from group 12345, max 200"

For Multiple Groups: Use batch processing or run multiple agents in parallel

🔮 What's Next?

Potential Enhancements:

Multi-Account Support
- Use ConnectSafely.ai's multi-account features
- Rotate between accounts for higher limits
Enrichment Pipeline
- Fetch member profiles with ConnectSafely.ai
- Enrich with additional APIs
- Score leads automatically
Automated Outreach
- Use ConnectSafely.ai's messaging features
- Send personalized connection requests
- Track response rates
Real-Time Monitoring
- Monitor groups for new premium members
- Alert when target profiles join
- Automatic lead capture

🎁 Complete Code

Full implementation: GitHub Repository

Quick Start Commands:

# Clone
git clone https://github.com/ConnectSafelyAI/agentic-framework-examples.git
cd agentic-framework-examples/extract-linkedin-premium-users-from-linkedin-groups/agentic/langGraph

# Install
bun install

# Configure
cp .env.example .env
# Edit .env with your ConnectSafely.ai token

# Run
bun start

💡 Key Takeaways

ConnectSafely.ai eliminates LinkedIn automation complexity
- No scraping required
- No account bans
- Enterprise-ready infrastructure
LangGraph enables agentic workflows
- Natural language interface
- Multi-step automation
- Extensible architecture
Together, they're powerful
- Build complex workflows in hours, not months
- Focus on business logic, not infrastructure
- Scale reliably

📚 Official Documentation

💬 Support Channels

Email Support: support@connectsafely.ai
Custom Workflows: Contact us for custom automation

🌐 Connect With Us

Stay updated with the latest automation tips, LinkedIn strategies, and platform updates:

Building a Complete LinkedIn Automation Agent with ConnectSafely.AI MCP

AMAAN SARFARAZ — Wed, 24 Dec 2025 11:49:36 +0000

From Months of Development to Full LinkedIn Automation in 1 Hour

Building comprehensive LinkedIn automation is a massive undertaking. You need separate tools for groups, posts, profiles, messaging, account management—each with their own authentication, rate limiting, and maintenance burden. This typically takes 3-6 months to build properly.

That's where ConnectSafely.AI changes everything.

In this tutorial, I'll show you how I got instant access to 20+ production-ready LinkedIn tools through ConnectSafely.AI's MCP server and built a complete automation agent in under an hour.

What is ConnectSafely.AI?

ConnectSafely.AI is a comprehensive LinkedIn automation platform that provides complete LinkedIn automation through the Model Context Protocol (MCP).

One API key gives you instant access to:

✅ 20+ LinkedIn Tools - Complete automation coverage
✅ All Operations - Groups, posts, profiles, messaging, accounts
✅ MCP Server - Industry-standard integration protocol
✅ Production-Ready - 99.9% uptime across all tools
✅ Zero Maintenance - ConnectSafely handles all updates
✅ Single Connection - One MCP endpoint for everything

Get started: https://connectsafely.ai/docs/integrations/mcp-server

Why I Chose ConnectSafely.AI

❌ The Traditional Approach:

// Building each tool separately...
async function getGroupMembers() { /* weeks of code */ }
async function searchPosts() { /* more weeks */ }
async function sendMessage() { /* even more weeks */ }
async function checkProfile() { /* you get it... */ }
// ... and 16 more tools to build
// ... plus authentication for each
// ... plus rate limiting for each
// ... plus maintenance when LinkedIn changes

✅ With ConnectSafely.AI:

// Get ALL tools instantly
import { MCPClient } from "@mastra/mcp";

const mcp = new MCPClient({
  servers: {
    connectsafely: {
      url: new URL(`https://mcp.connectsafely.ai/?apiKey=${apiKey}`)
    }
  }
});

const tools = await mcp.getTools();
// 20+ LinkedIn tools ready to use! 🎉

Time saved: 3-6 months → 1 hour

Tools available: 20+ complete operations

Maintenance: Zero

What We're Building

A complete LinkedIn automation agent with full access to:

🔵 Group Operations - Member extraction, analysis
📝 Post Operations - Search, scraping, engagement
👤 Profile Operations - Data fetching, relationships
💬 Messaging - Direct messages, InMail, connections
📊 Account Management - Status, warmup, activity

Example Usage:

# Group operations
> Get active members from AI Engineers group

# Post operations
> Search for top posts about "automation" from last week
> Comment on trending AI posts

# Profile operations
> Get profile data for these LinkedIn URLs
> Check if I'm connected to these profiles

# Messaging
> Send personalized connection requests to decision makers

# Account management
> Check my account health and recent activity

# Complex workflows
> Find premium members in SaaS groups, verify messaging support,
  and send personalized InMails

Architecture: Complete Automation via ConnectSafely

User Input (Natural Language)
    ↓
AI Agent (Gemini 2.5 Flash)
    ↓
┌──────────────────────────────────────────┐
│  ConnectSafely.AI MCP Server             │
│  (Complete LinkedIn Automation)          │
│                                          │
│  ✓ Group Operations (3+ tools)          │
│  ✓ Post Operations (7+ tools)           │
│  ✓ Profile Operations (4+ tools)        │
│  ✓ Messaging & Networking (3+ tools)    │
│  ✓ Account Management (3+ tools)        │
│                                          │
│  ALL via single MCP connection!         │
└──────────────────────────────────────────┘
    ↓
LinkedIn API (handled by ConnectSafely)
    ↓
Results → User

ConnectSafely.AI handles everything:

Authentication for all tools
Rate limiting across all operations
Data normalization for all responses
Error handling for all requests
Updates for all tools

Step 1: Get ConnectSafely.AI API Key

This single key unlocks ALL 20+ LinkedIn tools.

Step 2: Project Setup

git clone https://github.com/ConnectSafelyAI/agentic-framework-examples/tree/remote-mcp-integration/extract-linkedin-premium-users-from-linkedin-groups/mcp
cd extract-linkedin-premium-users-from-linkedin-groups/mcp

bun install

touch .env

Add to .env:

# Get from https://connectsafely.ai/docs/integrations/mcp-server
CONNECTSAFELY_API_KEY=your_key_here

# Get from https://aistudio.google.com/api-keys
GOOGLE_GENERATIVE_AI_API_KEY=your_gemini_key

GOOGLE_REFRESH_TOKEN=
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=

Step 3: Connect to ConnectSafely (Get ALL Tools)

Create src/mcp/connectsafely-client.ts:

import { MCPClient } from "@mastra/mcp";

// Connect to ConnectSafely MCP - get ALL tools
export const connectSafelyMCP = new MCPClient({
  servers: {
    connectsafely: {
      url: new URL(
        `https://mcp.connectsafely.ai/?apiKey=${process.env.CONNECTSAFELY_API_KEY}`
      ),
    },
  },
});

// Get complete LinkedIn toolkit from ConnectSafely
export async function getConnectSafelyTools() {
  try {
    const tools = await connectSafelyMCP.getTools();
    console.log(`✅ Connected to ConnectSafely MCP`);
    console.log(`📋 Loaded ${Object.keys(tools).length} LinkedIn tools\n`);

    // Log available tools
    Object.keys(tools).forEach((name, i) => {
      console.log(`   ${i + 1}. ${name}`);
    });

    return tools;
  } catch (error) {
    console.error("❌ Failed to connect:", error.message);
    throw error;
  }
}

export async function disconnectConnectSafely() {
  await connectSafelyMCP.disconnect();
}

You now have access to ALL ConnectSafely tools!

Step 4: Create AI Agent with Complete Toolkit

Create src/agent/linkedin-agent.ts:

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";
import { LibSQLStore } from "@mastra/libsql";
import { getConnectSafelyTools } from "../mcp/connectsafely-client.js";

export async function createLinkedInAgent() {
  // Get ALL tools from ConnectSafely
  const linkedInTools = await getConnectSafelyTools();

  const agent = new Agent({
    name: "Complete LinkedIn Automation Agent",
    model: "google/gemini-2.5-flash",

    instructions: `
You are a LinkedIn automation expert with FULL ACCESS to ConnectSafely's 
complete LinkedIn automation toolkit via MCP.

YOU HAVE ACCESS TO ALL TOOLS for:

GROUP OPERATIONS:
- Extract members from any group
- Analyze group activity
- Filter by premium status, verified status, industry, etc.

POST OPERATIONS:
- Search posts with advanced filters
- Scrape post details and engagement metrics
- Get all comments and replies
- Comment on posts
- React to posts (like, praise, appreciate, etc.)
- Track post performance

PROFILE OPERATIONS:
- Fetch complete profile data
- Get profile activity and posts
- Check relationship status
- Follow/unfollow profiles
- Verify messaging capabilities

MESSAGING & NETWORKING:
- Send direct messages
- Send InMail (premium messaging)
- Send connection requests
- Manage conversations

ACCOUNT MANAGEMENT:
- Monitor account status
- Track activity history
- Check warmup status
- Manage account health

Use ANY of these tools to accomplish the user's LinkedIn automation goals.
Be creative and combine tools for complex workflows.
    `,

    tools: linkedInTools, // ALL ConnectSafely tools

    memory: new Memory({
      storage: new LibSQLStore({
        url: "file:./mastra.db",
      }),
    }),
  });

  return agent;
}

Step 5: Create Interactive CLI

Create src/index.ts:

import "dotenv/config";
import readline from "readline";
import { createLinkedInAgent } from "./agent/linkedin-agent.js";
import { disconnectConnectSafely } from "./mcp/connectsafely-client.js";

async function main() {
  console.log("🚀 Initializing Complete LinkedIn Automation Agent...\n");

  const agent = await createLinkedInAgent();
  console.log("\n✅ Agent ready with ALL ConnectSafely tools!\n");

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  console.log("💬 Type 'list-tools' to see all available tools");
  console.log("💬 Type your automation requests or 'exit' to quit\n");

  function loop() {
    rl.question("> ", async (input) => {
      if (input.toLowerCase() === "exit") {
        await disconnectConnectSafely();
        rl.close();
        process.exit(0);
      }

      if (input.toLowerCase() === "list-tools") {
        console.log("\n📋 Available ConnectSafely Tools:\n");
        // Agent will list all available tools
        await agent.generate("List all available tools");
        loop();
        return;
      }

      if (!input.trim()) {
        loop();
        return;
      }

      try {
        const result = await agent.generate(input);
        console.log(`\n${result.text}\n`);
      } catch (error) {
        console.error(`\n❌ Error: ${error.message}\n`);
      }

      loop();
    });
  }

  loop();
}

main();

Step 6: Run It - Complete Automation!

npm start

> list-tools

📋 Available ConnectSafely Tools:

GROUP OPERATIONS:
1. Get_group_members_by_group_URL
2. Get_group_members_by_group_ID

POST OPERATIONS:
3. Search_posts_by_keyword
4. Scrape_LinkedIn_post_details
5. Get_comments_from_a_post
6. Get_all_comments_from_a_post
7. Comment_on_a_LinkedIn_post
8. React_to_a_LinkedIn_post
9. Reply_to_a_comment
10. Get_latest_posts_from_a_profile

PROFILE OPERATIONS:
11. Fetch_LinkedIn_profile_information
12. Check_relationship_status_with_profile
13. Follow_or_unfollow_a_LinkedIn_profile
14. Check_if_profile_supports_email_messaging

MESSAGING & NETWORKING:
15. Send_a_LinkedIn_message
16. Send_a_connection_request

ACCOUNT MANAGEMENT:
17. Get_account_status
18. Get_account_warmup_status
19. Get_account_activity_history

... and more!

> Search for posts about "AI automation" from last week

Agent: Searching LinkedIn posts using ConnectSafely...

[Tool: Search_posts_by_keyword - ConnectSafely]

✓ Found 23 posts about "AI automation" from last 7 days
✓ Top post: 456 likes, 89 comments
✓ Average engagement: 124 interactions/post

> Get all comments from the top post

Agent: Fetching comments using ConnectSafely...

[Tool: Get_all_comments_from_a_post - ConnectSafely]

✓ Retrieved 89 comments
✓ Top commenter: @username (5 comments)
✓ Most discussed: AI tools and automation platforms

> Check my account status

Agent: Checking account health via ConnectSafely...

[Tool: Get_account_status - ConnectSafely]

✓ Account status: Active
✓ Health: Good
✓ Warmup: Complete
✓ Recent activity: Normal

> exit

🔌 Disconnected from ConnectSafely
👋 Goodbye!

Complete ConnectSafely.AI Tool Catalog

🔵 Group Operations (ConnectSafely)

// Member extraction
Get_group_members_by_group_URL
Get_group_members_by_group_ID

// Features:
- Extract all members from any LinkedIn group
- Advanced filtering (premium, verified, industry, location)
- Pagination for large groups (1000+ members)
- Rich member data (profile, headline, company, etc.)

Use cases:

Lead generation
Market research
Competitor analysis
Network building

📝 Post Operations (ConnectSafely)

// Search & discovery
Search_posts_by_keyword
Scrape_LinkedIn_post_details
Get_latest_posts_from_a_profile

// Comment management
Get_comments_from_a_post
Get_all_comments_from_a_post
Reply_to_a_comment

// Engagement
Comment_on_a_LinkedIn_post
React_to_a_LinkedIn_post

// Features:
- Advanced search filters (date, sort, author job titles)
- Complete engagement metrics
- Comment pagination
- Multiple reaction types
- Post performance tracking

Use cases:

Content research
Social listening
Engagement automation
Trend analysis

👤 Profile Operations (ConnectSafely)

// Data fetching
Fetch_LinkedIn_profile_information
Get_latest_posts_from_a_profile

// Relationship management
Check_relationship_status_with_profile
Follow_or_unfollow_a_LinkedIn_profile
Check_if_profile_supports_email_messaging

// Features:
- Complete profile data (bio, experience, education, skills)
- Contact information (when available)
- Activity history
- Connection degree
- Messaging capability verification

Use cases:

Profile enrichment
CRM integration
Prospect research
Relationship tracking

💬 Messaging & Networking (ConnectSafely)

// Communication
Send_a_LinkedIn_message
Send_a_connection_request

// Features:
- Direct messaging (normal + InMail)
- Personalized connection requests
- Custom message templates
- Message type detection
- Delivery confirmation

Use cases:

Outreach campaigns
Network building
Sales prospecting
Relationship nurturing

📊 Account Management (ConnectSafely)

// Monitoring
Get_account_status
Get_account_warmup_status
Get_account_activity_history

// Features:
- Real-time account health
- Warmup progress tracking
- Activity history and patterns
- Safety status monitoring
- Compliance checking

Use cases:

Account health monitoring
Compliance tracking
Activity auditing
Risk management

Real-World Workflows

1. Complete Lead Pipeline

> Find active members in "SaaS Founders" group who post regularly,
  get their profiles, check if we're connected, verify messaging support,
  and send personalized connection requests to qualified leads

ConnectSafely tools used:

Get_group_members_by_group_URL
Get_latest_posts_from_a_profile
Check_relationship_status_with_profile
Check_if_profile_supports_email_messaging
Send_a_connection_request

Result: Complete automated lead pipeline

2. Content Intelligence System

> Search for trending posts about AI, get all comments,
  analyze top commenters, check their profiles,
  and identify potential collaboration partners

ConnectSafely tools used:

Search_posts_by_keyword
Get_all_comments_from_a_post
Fetch_LinkedIn_profile_information
Check_relationship_status_with_profile

Result: Automated content research and network discovery

3. Competitor Monitoring

> Get all recent posts from @competitor account,
  analyze engagement patterns, extract active commenters,
  check their profiles and industries

ConnectSafely tools used:

Get_latest_posts_from_a_profile
Scrape_LinkedIn_post_details
Get_all_comments_from_a_post
Fetch_LinkedIn_profile_information

Result: Comprehensive competitive intelligence

4. Network Growth Automation

> Check my account status, find premium members in target groups,
  verify we're not connected, send personalized requests,
  and track my activity

ConnectSafely tools used:

Get_account_status
Get_group_members_by_group_URL
Check_relationship_status_with_profile
Send_a_connection_request
Get_account_activity_history

Result: Automated, compliant network building

Performance Metrics

ConnectSafely.AI Performance

Metric	Value
Tools Available	20+
Setup Time	< 5 minutes
Uptime	99.9%
Response Time	< 2 seconds
Rate Limit	60 req/min
Daily Operations	1000+

My Automation Results

Operation	Time	Success	Tools Used
Complete lead pipeline	15 sec	100%	5 tools
Content intelligence	8 sec	100%	4 tools
Competitor analysis	12 sec	100%	4 tools
Network automation	10 sec	100%	5 tools

All powered by ConnectSafely.AI's complete toolkit!

Cost Analysis

Building All Tools vs ConnectSafely

Aspect	DIY (All Tools)	ConnectSafely.AI
Development	$50,000-$100,000 (3-6 months)	$0 (1 hour)
Tools Built	5-10 typical	20+ included
Maintenance	$2,000/month	$0
Infrastructure	$500/month	Included
Monitoring	$200/month	Included
Updates	Manual for each	Auto for all

Why ConnectSafely.AI Wins

✅ Complete Coverage

20+ tools vs building 5-10
All operations in one place
Single integration for everything

✅ Zero Maintenance

Automatic updates for all tools
Breaking changes handled by ConnectSafely
Focus on product not infrastructure

✅ Enterprise Quality

99.9% uptime for all tools
Built-in safety across all operations
Production-ready from day one

✅ Developer Experience

MCP standard integration
One API key for everything
Comprehensive docs for all tools

Getting Started

# 1. Sign up
https://connectsafely.ai/docs/integrations/mcp-server

# 2. Install
npm install @mastra/mcp @mastra/core

# 3. Connect (3 lines!)
const mcp = new MCPClient({
  servers: {
    connectsafely: {
      url: new URL(`https://mcp.connectsafely.ai/?apiKey=${key}`)
    }
  }
});

# 4. Get ALL tools
const tools = await mcp.getTools();

# 5. Build anything!

Time to complete automation: 30 minutes

Common Questions

Q: Do I get all 20+ tools with one API key?

A: Yes! One key = full toolkit

Q: What if I only need specific tools?

A: You get access to all tools, use what you need

Q: Does ConnectSafely handle rate limiting?

A: Yes, automatically across all tools

Q: What about account safety?

A: Built-in warmup and safety for all operations

Q: Can I build commercial products?

A: Yes, all plans support commercial use

Resources

ConnectSafely.AI

Website: https://connectsafely.ai
MCP Server: https://connectsafely.ai/docs/integrations/mcp-server
Documentation: https://connectsafely.ai/docs
API Reference: https://connectsafely.ai/docs/api
Full Code Repo: gitHub

Additional

Mastra: https://mastra.ai
MCP Spec: https://modelcontextprotocol.io
Source Code: GitHub

Conclusion

Complete LinkedIn automation used to take 3-6 months to build. With ConnectSafely.AI, you get the full toolkit in under an hour.

What I got with ConnectSafely.AI:

✅ 20+ production-ready tools
✅ Complete LinkedIn automation coverage
✅ Single MCP connection
✅ Zero maintenance
✅ Enterprise reliability
✅ Saved months of development

Stop building tools one by one. Get complete automation instantly.

Get your API key: https://connectsafely.ai/docs/integrations/mcp-server

Your Turn

Building LinkedIn automation? What tools do you need most?

Trying ConnectSafely.AI? Share your experience!

Questions? Drop a comment below!