SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Grafbase MCP with LangChain

Connect LangChain to Grafbase MCP. Retrieve the latest audit log entry, delete a specific api key by id, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Grafbase logoGrafbase
Api Key

Grafbase is a platform for building and scaling GraphQL APIs with edge caching and unified data access. It's designed to help you deliver fast, secure, and seamless APIs—all in one place.

28 Tools

Introduction

This guide walks you through connecting Grafbase to LangChain using the Composio tool router. By the end, you'll have a working Grafbase agent that can fetch federated and subgraph schemas, review schema checks, enable and disable MCP servers, browse audit logs, and manage API keys through natural language commands.

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

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

Also integrate Grafbase with

Claude CodeClaude CoworkOpenAI Agents SDKClaude Agent SDKGrok BotCodexOpenClawHermesAtomic AgentGoogle ADKVercel AI SDKMastra AILlamaIndexCrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Connect your Grafbase project to Composio
  • Create a Tool Router MCP session for Grafbase
  • Initialize an MCP client and retrieve Grafbase tools
  • Build a LangChain agent that can interact with Grafbase
  • Set up an interactive chat interface for testing

What is LangChain?

LangChain is a framework for developing applications powered by language models. It provides tools and abstractions for building agents that can reason, use tools, and maintain conversation context.

Key features include:

  • Agent Framework: Build agents that can use tools and make decisions
  • MCP Integration: Connect to external services through Model Context Protocol adapters
  • Memory Management: Maintain conversation history across interactions
  • Multi-Provider Support: Works with OpenAI, Anthropic, and other LLM providers

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

The Grafbase MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, and more directly to your Grafbase account. It provides structured and secure access to your GraphQL API management, so your agent can perform actions like enabling or disabling MCP, managing API keys, retrieving schemas, and working with audit logs on your behalf.

  • Enable or disable MCP server: Instantly activate or turn off the Model Context Protocol for your Grafbase project, all by agent command.
  • API key management: Let your agent securely delete existing API keys to control and rotate access as needed.
  • Schema and federation management: Retrieve federated graph schemas or remove unwanted schemas for streamlined development workflows.
  • Audit log retrieval: Fetch specific audit log entries, giving your agent the power to surface key changes or events in your Grafbase environment.
  • Extension and server configuration cleanup: Delete extension configurations or obsolete MCP server setups to keep your backend lean and secure.

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

What is Composio SDK?

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

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

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

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

Step-by-step Guide

Step by step10 STEPS
1

Prerequisites

Before starting this tutorial, make sure you have:
  • Python 3.10 or higher installed on your system
  • A Composio account with an API key
  • An OpenAI API key
  • Basic familiarity with Python and async programming
2

Getting API Keys for OpenAI and Composio

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

Install dependencies

npm install @composio/langchain @langchain/core @langchain/openai @langchain/mcp-adapters dotenv

Install the required packages for LangChain with MCP support.

What's happening:

  • @composio/langchain provides Composio integration for LangChain
  • @langchain/mcp-adapters enables MCP client connections
  • @langchain/core is the core agent framework
  • dotenv/config loads environment variables
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_composio_user_id_here
OPENAI_API_KEY=your_openai_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates your requests to Composio's API
  • COMPOSIO_USER_ID identifies the user for session management
  • OPENAI_API_KEY enables access to OpenAI's language models
5

Import dependencies

import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

dotenv.config();
What's happening:
  • We're importing LangChain's MCP adapter and Composio SDK
  • The dotenv/config import loads environment variables from your .env file
  • This setup prepares the foundation for connecting LangChain with Grafbase functionality through MCP
6

Initialize Composio client

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });
What's happening:
  • We're loading the COMPOSIO_API_KEY from environment variables and validating it exists
  • Creating a Composio instance that will manage our connection to Grafbase tools
  • Validating that COMPOSIO_USER_ID is also set before proceeding
7

Create a Tool Router session

const session = await composio.create(
    userId as string,
    {
        toolkits: ['grafbase']
    }
);

const url = session.mcp.url;
What's happening:
  • We're creating a Tool Router session that gives your agent access to Grafbase tools
  • The create method takes the user ID and specifies which toolkits should be available
  • The returned session.mcp.url is the MCP server URL that your agent will use
  • This approach allows the agent to dynamically load and use Grafbase tools as needed
8

Configure the agent with the MCP URL

const client = new MultiServerMCPClient({
    "grafbase-agent": {
        transport: "http",
        url: url,
        headers: {
            "x-api-key": process.env.COMPOSIO_API_KEY
        }
    }
});

const tools = await client.getTools();

const agent = createAgent({ model: "gpt-5", tools });
What's happening:
  • We're creating a MultiServerMCPClient that connects to our Grafbase MCP server via HTTP
  • The client is configured with a name and the URL from our Tool Router session
  • getTools() retrieves all available Grafbase tools that the agent can use
  • We're creating a LangChain agent using the GPT-5 model
9

Set up interactive chat interface

let conversationHistory: any[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log("Ask any Grafbase related question or task to the agent.\n");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
});

rl.prompt();

rl.on('line', async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
        console.log("\nGoodbye!");
        rl.close();
        process.exit(0);
    }

    if (!trimmedInput) {
        rl.prompt();
        return;
    }

    conversationHistory.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    const response = await agent.invoke({ messages: conversationHistory });
    conversationHistory = response.messages;

    const finalResponse = response.messages[response.messages.length - 1]?.content;
    console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\n👋 Session ended.');
        process.exit(0);
    });
What's happening:
  • We initialize an empty conversationHistory list to maintain context across interactions
  • A readline interface is used to continuously accept user input from the command line
  • When a user types a message, it's added to the conversation history and sent to the agent
  • The agent processes the request using the invoke() method with the full conversation history
  • Users can type 'exit', 'quit', or 'bye' to end the chat session gracefully
10

Run the application

main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});
What's happening:
  • We call the main() function to start the application

Complete Code

Here's the complete code to get you started with Grafbase and LangChain:

import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";  
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });

    const session = await composio.create(
        userId as string,
        {
            toolkits: ['grafbase']
        }
    );

    const url = session.mcp.url;
    
    const client = new MultiServerMCPClient({
        "grafbase-agent": {
            transport: "http",
            url: url,
            headers: {
                "x-api-key": process.env.COMPOSIO_API_KEY
            }
        }
    });
    
    const tools = await client.getTools();
  
    const agent = createAgent({ model: "gpt-5", tools });
    
    let conversationHistory: any[] = [];
    
    console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
    console.log("Ask any Grafbase related question or task to the agent.\n");
    
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
        prompt: 'You: '
    });

    rl.prompt();

    rl.on('line', async (userInput: string) => {
        const trimmedInput = userInput.trim();
        
        if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
            console.log("\nGoodbye!");
            rl.close();
            process.exit(0);
        }
        
        if (!trimmedInput) {
            rl.prompt();
            return;
        }
        
        conversationHistory.push({ role: "user", content: trimmedInput });
        console.log("\nAgent is thinking...\n");
        
        const response = await agent.invoke({ messages: conversationHistory });
        conversationHistory = response.messages;
        
        const finalResponse = response.messages[response.messages.length - 1]?.content;
        console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\nSession ended.');
        process.exit(0);
    });
}

main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});

Conclusion

You've successfully built a LangChain agent that can interact with Grafbase through Composio's Tool Router.

Key features of this implementation:

  • Dynamic tool loading through Composio's Tool Router
  • Conversation history maintenance for context-aware responses
  • Async Python provides clean, efficient execution of agent workflows
You can extend this further by adding error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.
TOOLS

Supported Tools

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

Add Zitadel Redirect URI

Request addition of a Zitadel OAuth redirect in Grafbase using the authenticated context.

Assign Team Role

Tool to assign a role to a team member in Grafbase.

Delete Grafbase API Key

Delete a Grafbase API key (access token) by ID.

Delete Grafbase Audit Log

Tool to delete a specific Grafbase audit log entry.

Delete Extension

Attempt to delete a Grafbase extension configuration by its unique ID through the project API.

Delete MCP Server

Attempt to delete a Grafbase MCP server configuration by its unique ID through the project API.

Delete Grafbase Subgraph

Tool to delete a subgraph from a Grafbase federated graph.

Delete Schema Check

Query a Grafbase schema check by ID and return information about the check or an API error.

Delete Grafbase Team

Tool to delete a team from the Grafbase organization.

Disable MCP Server

Attempt to disable the Model Context Protocol (MCP) server for a Grafbase project through its API.

Enable Grafbase MCP Server

Attempt to enable MCP on a Grafbase gateway via its API, returning manual configuration guidance if the endpoint is unsupported or unreachable.

Get Grafbase Audit Log

Search accessible Grafbase organization members by user ID, name, email, or role, optionally scoped to an organization.

Get Extension by Name

Tool to retrieve a Grafbase extension by its name.

Get Extension Version By Name And Version

Tool to retrieve details of a specific Grafbase extension version by name and version.

Get Federated Schema

Retrieves the composed federated graph schema from Grafbase in SDL format.

Get Grafbase Invitation

Retrieve details of a specific Grafbase invitation by ID, including its status, email address, and creation date.

Get Notifications Inbox Messages

Tool to retrieve notifications inbox messages for the authenticated Grafbase user.

Get Grafbase Schema Check

Retrieve a Grafbase schema check by ID within an account and graph, returning its error count, subgraph name and available Git commit information.

Get Subgraph Schema

Retrieve the GraphQL SDL schema for a subgraph by name.

List API Keys

List all API keys (access tokens) for the authenticated Grafbase user.

List Grafbase Audit Logs

List Grafbase organization member-join activity derived from organization membership data, with optional organization filtering.

List Extensions

List extensions returned by available Grafbase project REST endpoints.

List MCP Servers

Check a Grafbase gateway's presumed /mcp endpoint and provide configuration guidance.

List Grafbase Schema Checks

List schema checks for a Grafbase graph.

List Grafbase Schemas

Tool to list all schemas in the Grafbase schema registry.

List Grafbase Subgraphs

List published subgraphs and their endpoint URLs across Grafbase organizations, optionally filtering by branch name.

Mark Notifications as Read

Tool to mark Grafbase notifications as read.

Remove Graph Owner

Tool to remove an owner from a Grafbase graph.

FRAMEWORKS

How to build Grafbase MCP Agent with another framework

Claude Code logo

Claude Code

Use Grafbase MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Grafbase MCP with Claude Cowork

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Grafbase MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Grafbase MCP with Claude Agent SDK

Grok Bot logo

Grok Bot

Use Grafbase MCP with Grok Bot

Codex logo

Codex

Use Grafbase MCP with Codex

OpenClaw logo

OpenClaw

Use Grafbase MCP with OpenClaw

Hermes logo

Hermes

Use Grafbase MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Grafbase MCP with Atomic Agent

Google ADK logo

Google ADK

Use Grafbase MCP with Google ADK

Vercel AI SDK logo

Vercel AI SDK

Use Grafbase MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Grafbase MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Grafbase MCP with LlamaIndex

CrewAI logo

CrewAI

Use Grafbase MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Grafbase MCP with Pydantic AI

AutoGen logo

AutoGen

Use Grafbase MCP with AutoGen

FAQ

Frequently asked questions

With a standalone Grafbase MCP server, the agents and LLMs can only access a fixed set of Grafbase tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Grafbase and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. LangChain fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Grafbase tools.

Yes, absolutely. You can configure which Grafbase scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Grafbase data and credentials are handled as safely as possible.

Start with Grafbase.It takes 30 seconds.

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

Start building