LangChain Integration — Build AI Agents with LinkedIn Data

import os
import time
import requests
from langchain.tools import tool

OUTX_API_KEY = os.environ["OUTX_API_KEY"]
BASE_URL = "https://api.outx.ai"
HEADERS = {"x-api-key": OUTX_API_KEY, "Content-Type": "application/json"}


@tool
def fetch_linkedin_profile(profile_slug: str) -> dict:
    """Fetch a LinkedIn profile by slug. Returns name, headline, location, experience."""
    # Create task
    resp = requests.post(
        f"{BASE_URL}/linkedin-agent/fetch-profile",
        headers=HEADERS,
        json={"profile_slug": profile_slug},
    )
    task_id = resp.json()["api_agent_task_id"]

    # Poll for result
    for _ in range(30):
        result = requests.get(
            f"{BASE_URL}/linkedin-agent/get-task-status",
            headers={"x-api-key": OUTX_API_KEY},
            params={"api_agent_task_id": task_id},
        ).json()

        if result["data"]["status"] == "completed":
            return result["data"]["task_output"]
        if result["data"]["status"] == "failed":
            return {"error": "Task failed", "output": result["data"]["task_output"]}

        time.sleep(5)

    return {"error": "Task timed out"}


@tool
def get_watchlist_posts(watchlist_id: str, page: int = 1) -> dict:
    """Get recent LinkedIn posts from a watchlist. Returns post content, author, engagement metrics."""
    resp = requests.get(
        f"{BASE_URL}/api-posts",
        headers={"x-api-key": OUTX_API_KEY},
        params={
            "watchlist_id": watchlist_id,
            "sort_by": "recent_first",
            "page": page,
        },
    )
    return resp.json()


@tool
def comment_on_post(post_id: str, user_email: str, comment_text: str) -> dict:
    """Comment on a LinkedIn post from a watchlist. Requires post_id from get_watchlist_posts."""
    resp = requests.post(
        f"{BASE_URL}/api-comment",
        headers=HEADERS,
        json={
            "post_id": post_id,
            "user_email": user_email,
            "comment_text": comment_text,
            "actor_type": "user",
        },
    )
    return resp.json()

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate

# Define tools
tools = [fetch_linkedin_profile, get_watchlist_posts, comment_on_post]

# Create prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a LinkedIn research assistant. You can:
1. Fetch LinkedIn profiles to learn about people
2. Get posts from watchlists to find relevant conversations
3. Comment on posts (only when explicitly asked)

When fetching profiles, extract the profile slug from LinkedIn URLs.
For linkedin.com/in/williamhgates, the slug is 'williamhgates'.

Always be respectful and professional in any comments you generate."""),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

# Create agent
llm = ChatOpenAI(model="gpt-4o")
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run
result = executor.invoke({
    "input": "Fetch the LinkedIn profile for williamhgates and summarize their background"
})
print(result["output"])

result = executor.invoke({
    "input": """Check watchlist WATCHLIST_ID for posts with buying intent
    (people asking for tool recommendations, comparing solutions, or expressing pain points).
    For the top 3 most relevant posts, draft a helpful comment that adds value
    without being salesy. Show me the drafts but do NOT post them yet."""
})