How to Use the Fathom MCP in LangChain

Q: Can I trace Fathom API latency in LangChain?

Yes. When your LangChain agent calls getactionitems or gethighlights, LangSmith traces the execution. You can inspect the exact API latency, token count, and raw tool output inside your LangSmith dashboard.

Q: How does LangChain handle large transcripts from Fathom?

If gettranscript returns a massive payload, your LangChain chain can split the text using a recursive character text splitter. You then run a map-reduce chain to summarize the conversation before passing it to other tools.

Q: Can I search past team meetings using this setup?

Yes. Your agent can call searchmeetings with a keyword or query getteammeetings to retrieve shared calls. The agent then parses the results to find specific discussions without manual searching.

Run multi-step reasoning chains over your Fathom meeting data using LangChain and LangSmith.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Fathom MCP to LangChain

Create your Vinkius account to connect Fathom to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Fathom with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Multi-step meeting analysis with LangChain

The Fathom MCP Server lets your LangChain agents fetch meeting records and pass them directly into your processing chains. Your agent starts by calling `list_meetings` or `search_meetings` to locate the right session, then immediately pipes that ID into `get_transcript` or `get_summary`. This lets you build chains that process raw call records without copy-pasting text between tabs. Because LangChain handles tool output as chain inputs, you can feed the resulting text straight into a summarizer or a custom prompt. If the agent needs to track who said what, it calls `get_attendees` to map speaker names to the transcript blocks. You monitor this entire sequence of tool executions inside LangSmith to see exactly how much latency each Fathom call adds to your workflow.

Trace Fathom tool calls in LangSmith

This MCP Server exposes tools like `get_action_items` and `get_highlights` that your LangChain agent executes as discrete links in a chain. When your agent runs a prompt to analyze team performance, LangSmith traces the exact payload returned by `get_team_meetings`. You see the raw JSON, the latency of the API call, and how your LLM used those specific action items. Debugging agentic loops becomes straightforward when you can inspect the inputs of `get_recording` alongside your chain's reasoning steps. If an agent fails to extract the correct follow-ups, you check the LangSmith trace to see if `get_transcript` returned truncated data or if your prompt template is what actually broke.

Build autonomous follow-up chains

The Fathom MCP Server provides direct access to real-time meeting updates through `get_webhooks`. Your LangChain agent listens for these events, then automatically triggers a chain that calls `get_summary` and `get_me` to draft personalized follow-up emails from your account. You don't have to write custom integration code for every new meeting event. By combining these tools with LangChain's 500+ integrations, you can write a chain that takes the output of `get_action_items` and pushes it directly to your task manager. The agent decides when to pull the full transcript using `get_transcript` based on how detailed the action items are, making your post-meeting automation dynamic and context-aware.

Setup guide

Set up Fathom MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Fathom tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "fathom-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Fathom transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Fathom. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Fathom now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Fathom MCP in LangChain

You register the Fathom MCP Server with the MultiServerMCPClient in your Python code. Call client.get_tools() to retrieve tools like `get_transcript` and `get_summary`, then pass them directly to your LangChain agent's tool list.

Yes. When your LangChain agent calls `get_action_items` or `get_highlights`, LangSmith traces the execution. You can inspect the exact API latency, token count, and raw tool output inside your LangSmith dashboard.

If `get_transcript` returns a massive payload, your LangChain chain can split the text using a recursive character text splitter. You then run a map-reduce chain to summarize the conversation before passing it to other tools.

Yes. Your agent can call `search_meetings` with a keyword or query `get_team_meetings` to retrieve shared calls. The agent then parses the results to find specific discussions without manual searching.

Yes. Your transcripts, summaries, and recording URLs retrieved via `get_transcript` and `get_recording` stay local to your execution environment. Vinkius runs the server in an isolated sandbox, meaning your raw meeting audio and text data never touch third-party servers.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript