# How to integrate Campaign cleaner MCP with LangChain

```json
{
  "title": "How to integrate Campaign cleaner MCP with LangChain",
  "toolkit": "Campaign cleaner",
  "toolkit_slug": "campaign_cleaner",
  "framework": "LangChain",
  "framework_slug": "langchain",
  "url": "https://composio.dev/toolkits/campaign_cleaner/framework/langchain",
  "markdown_url": "https://composio.dev/toolkits/campaign_cleaner/framework/langchain.md",
  "updated_at": "2026-09-24T10:59:54.621Z"
}
```

## Introduction

This guide walks you through connecting Campaign cleaner to LangChain using the Composio tool router. By the end, you'll have a working Campaign cleaner agent that can list all campaigns created this week, download pdf analysis for latest campaign, check status of your july newsletter campaign through natural language commands.
This guide will help you understand how to give your LangChain agent real control over a Campaign cleaner account through Composio's Campaign cleaner MCP server.
Before we dive in, let's take a quick look at the key ideas and tools involved.

## Also integrate Campaign cleaner with

- [Claude Code](https://composio.dev/toolkits/campaign_cleaner/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/campaign_cleaner/framework/claude-cowork)
- [OpenAI Agents SDK](https://composio.dev/toolkits/campaign_cleaner/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/campaign_cleaner/framework/claude-agents-sdk)
- [Codex](https://composio.dev/toolkits/campaign_cleaner/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/campaign_cleaner/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/campaign_cleaner/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/campaign_cleaner/framework/atomic-agent)
- [Google ADK](https://composio.dev/toolkits/campaign_cleaner/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/campaign_cleaner/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/campaign_cleaner/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/campaign_cleaner/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/campaign_cleaner/framework/crew-ai)
- [Pydantic AI](https://composio.dev/toolkits/campaign_cleaner/framework/pydantic-ai)
- [AutoGen](https://composio.dev/toolkits/campaign_cleaner/framework/autogen)

## TL;DR

Here's what you'll learn:
- Get and set up your OpenAI and Composio API keys
- Connect your Campaign cleaner project to Composio
- Create a Tool Router MCP session for Campaign cleaner
- Initialize an MCP client and retrieve Campaign cleaner tools
- Build a LangChain agent that can interact with Campaign cleaner
- 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 Campaign cleaner MCP server, and what's possible with it?

The Campaign cleaner MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Campaign cleaner account. It provides structured and secure access to your email campaign data, so your agent can perform actions like listing campaigns, checking campaign status, downloading analysis reports, and deleting campaigns on your behalf.
- Comprehensive campaign listing and retrieval: Easily ask your agent to fetch a complete list of all your saved email campaigns for review, reporting, or management.
- Real-time campaign status monitoring: Let your agent check the processing status of any submitted campaign, so you always know where your campaigns stand.
- Automated PDF analysis downloads: Direct your agent to download detailed PDF analysis reports for any processed campaign, streamlining your optimization workflow.
- Campaign deletion and cleanup: Have your agent safely remove outdated or unnecessary campaigns by confirming and deleting them by ID.

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `CAMPAIGN_CLEANER_DELETE_CAMPAIGN` | Delete Campaign | Tool to delete a saved campaign by ID. Use when you need to remove a campaign after confirming its ID. |
| `CAMPAIGN_CLEANER_GET_CAMPAIGN_LIST` | Get Campaign List | Tool to list all campaigns in the account. Use when you need to retrieve campaign listings for reporting or management. |
| `CAMPAIGN_CLEANER_GET_CAMPAIGN_PDF_ANALYSIS` | Download Campaign PDF Analysis | Download a PDF analysis report for a processed campaign. The report includes deliverability analysis, spam score assessment, and optimization recommendations. Use this after a campaign has been submitted via send_campaign and processing is complete. |
| `CAMPAIGN_CLEANER_GET_CAMPAIGN_STATUS` | Get Campaign Status | Tool to check the processing status of a submitted campaign. Use after submitting a campaign to monitor its progress. |
| `CAMPAIGN_CLEANER_GET_CREDITS` | Get Credits | Tool to retrieve the number of available credits in your Campaign Cleaner account. Credits are consumed when calling the send_campaign API. |

## Supported Triggers

None listed.

## Creating MCP Server - Stand-alone vs Composio SDK

The Campaign cleaner MCP server is an implementation of the Model Context Protocol that connects your AI agent to Campaign cleaner. It provides structured and secure access so your agent can perform Campaign cleaner operations on your behalf through a secure, permission-based interface.
With Composio's managed implementation, you don't have to create your own developer app. For production, if you're building an end product, we recommend using your own credentials. The managed server helps you prototype fast and go from 0-1 faster.

## Step-by-step Guide

### 1. Prerequisites

No description provided.

### 1. Getting API Keys for OpenAI and Composio

OpenAI API Key
- Go to the [OpenAI dashboard](https://platform.openai.com/settings/organization/api-keys) 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](https://dashboard.composio.dev?utm_source=toolkits&utm_medium=framework_docs).
- Navigate to your API settings and generate a new API key.
- Store this key securely as you'll need it for authentication.

### 2. Install dependencies

No description provided.
```python
pip install composio-langchain langchain-mcp-adapters langchain python-dotenv
```

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

### 3. Set up environment variables

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
```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
```

### 4. Import dependencies

No description provided.
```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()
```

```typescript
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();
```

### 5. Initialize Composio client

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 Campaign cleaner tools
- Validating that COMPOSIO_USER_ID is also set before proceeding
```python
async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))

    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
```

```typescript
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()
    });
```

### 6. Create a Tool Router session

What's happening:
- We're creating a Tool Router session that gives your agent access to Campaign cleaner 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 Campaign cleaner tools as needed
```python
# Create Tool Router session for Campaign cleaner
session = composio.create(
    user_id=os.getenv("COMPOSIO_USER_ID"),
    toolkits=['campaign_cleaner']
)

url = session.mcp.url
```

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

const url = session.mcp.url;
```

### 7. Configure the agent with the MCP URL

No description provided.
```python
client = MultiServerMCPClient({
    "campaign_cleaner-agent": {
        "transport": "streamable_http",
        "url": session.mcp.url,
        "headers": {
            "x-api-key": os.getenv("COMPOSIO_API_KEY")
        }
    }
})

tools = await client.get_tools()

agent = create_agent("gpt-5", tools)
```

```typescript
const client = new MultiServerMCPClient({
    "campaign_cleaner-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 });
```

### 8. Set up interactive chat interface

No description provided.
```python
conversation_history = []

print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Campaign cleaner related question or task to the agent.\n")

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

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

    if not user_input:
        continue

    conversation_history.append({"role": "user", "content": user_input})
    print("\nAgent is thinking...\n")

    response = await agent.ainvoke({"messages": conversation_history})
    conversation_history = response['messages']
    final_response = response['messages'][-1].content
    print(f"Agent: {final_response}\n")
```

```typescript
let conversationHistory: any[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log("Ask any Campaign cleaner 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);
    });
```

### 9. Run the application

No description provided.
```python
if __name__ == "__main__":
    asyncio.run(main())
```

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

## Complete Code

```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()

async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    
    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
    
    session = composio.create(
        user_id=os.getenv("COMPOSIO_USER_ID"),
        toolkits=['campaign_cleaner']
    )

    url = session.mcp.url
    
    client = MultiServerMCPClient({
        "campaign_cleaner-agent": {
            "transport": "streamable_http",
            "url": url,
            "headers": {
                "x-api-key": os.getenv("COMPOSIO_API_KEY")
            }
        }
    })
    
    tools = await client.get_tools()
  
    agent = create_agent("gpt-5", tools)
    
    conversation_history = []
    
    print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
    print("Ask any Campaign cleaner related question or task to the agent.\n")
    
    while True:
        user_input = input("You: ").strip()
        
        if user_input.lower() in ['exit', 'quit', 'bye']:
            print("\nGoodbye!")
            break
        
        if not user_input:
            continue
        
        conversation_history.append({"role": "user", "content": user_input})
        print("\nAgent is thinking...\n")
        
        response = await agent.ainvoke({"messages": conversation_history})
        conversation_history = response['messages']
        final_response = response['messages'][-1].content
        print(f"Agent: {final_response}\n")

if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
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: ['campaign_cleaner']
        }
    );

    const url = session.mcp.url;
    
    const client = new MultiServerMCPClient({
        "campaign_cleaner-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 Campaign cleaner 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 Campaign cleaner 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.

## How to build Campaign cleaner MCP Agent with another framework

- [Claude Code](https://composio.dev/toolkits/campaign_cleaner/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/campaign_cleaner/framework/claude-cowork)
- [OpenAI Agents SDK](https://composio.dev/toolkits/campaign_cleaner/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/campaign_cleaner/framework/claude-agents-sdk)
- [Codex](https://composio.dev/toolkits/campaign_cleaner/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/campaign_cleaner/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/campaign_cleaner/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/campaign_cleaner/framework/atomic-agent)
- [Google ADK](https://composio.dev/toolkits/campaign_cleaner/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/campaign_cleaner/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/campaign_cleaner/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/campaign_cleaner/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/campaign_cleaner/framework/crew-ai)
- [Pydantic AI](https://composio.dev/toolkits/campaign_cleaner/framework/pydantic-ai)
- [AutoGen](https://composio.dev/toolkits/campaign_cleaner/framework/autogen)

## Related Toolkits

- [Metaads](https://composio.dev/toolkits/metaads) - Metaads is Meta's official Ads API that lets you manage, analyze, and optimize your Facebook and Instagram ad campaigns. Streamline ad operations and gain deeper insights with robust automation.
- [Adrapid](https://composio.dev/toolkits/adrapid) - Adrapid is a platform for rapid creation of digital marketing visuals using templates. It streamlines design workflows for banners, images, and HTML5 content with automation.
- [AdRoll](https://composio.dev/toolkits/adroll) - AdRoll is a digital marketing platform for managing advertising campaigns, audiences, and account-based marketing. It helps marketers retarget customers across channels and measure performance.
- [Adtraction](https://composio.dev/toolkits/adtraction) - Adtraction is an affiliate marketing platform for partner programs, tracking links, transactions, commissions, statistics, and payments. It helps advertisers and publishers manage performance marketing with clear reporting and payout workflows.
- [Adyntel](https://composio.dev/toolkits/adyntel) - Adyntel is an API that retrieves LinkedIn ads for any company using a domain or LinkedIn Page ID. Easily access competitive ad intelligence to power your marketing workflows.
- [Beaconstac](https://composio.dev/toolkits/beaconstac) - Beaconstac is a platform for creating and managing QR codes and proximity beacons. It helps businesses engage customers and track marketing performance with powerful analytics.
- [Bouncify](https://composio.dev/toolkits/bouncify) - Bouncify is an email verification service for single addresses and bulk lists. Use it to reduce bounces, protect sender reputation, and track verification credits.
- [Bulk Email Checker](https://composio.dev/toolkits/bulk_email_checker) - Bulk Email Checker is an email verification service for checking address validity, mailbox status, domains, and mail-server signals. It helps reduce bounces, spot risky emails, and keep outreach lists cleaner before you send.
- [Deadline funnel](https://composio.dev/toolkits/deadline_funnel) - Deadline Funnel lets you create personalized deadlines and timers for your marketing campaigns. It helps marketers boost conversions by adding authentic urgency to offers.
- [DeBounce](https://composio.dev/toolkits/debounce) - DeBounce is an email verification service for checking address validity, deliverability, and risk. It helps keep contact lists clean so your campaigns reach real inboxes.
- [Easy Email Verification](https://composio.dev/toolkits/easy_email_verification) - Easy Email Verification is an email validation service for checking single addresses and bulk lists. Use it to reduce bounces, clean contact data, and protect sender reputation.
- [Elastic Email](https://composio.dev/toolkits/elastic_email) - Elastic Email is an email delivery and marketing platform for transactional emails, campaigns, contacts, and reporting. Use it to send reliable emails, manage audiences, verify addresses, and track performance.
- [Fairing](https://composio.dev/toolkits/fairing) - Fairing is a post-purchase survey and attribution platform for ecommerce brands. It helps teams measure which marketing channels, campaigns, and customer touchpoints drive purchases.
- [GoDaddy MCP](https://composio.dev/toolkits/godaddy_mcp) - GoDaddy MCP is a domain discovery toolkit for checking availability and generating AI-powered name ideas. Use it to move from rough business keywords to practical domain options fast.
- [Google Ads](https://composio.dev/toolkits/googleads) - Google Ads is Google's online advertising platform for creating, managing, and optimizing digital campaigns. It helps businesses reach targeted customers and maximize return on ad spend.
- [Handwrite.io](https://composio.dev/toolkits/handwrite) - Handwrite.io is a direct mail service for creating physical handwritten card orders. It helps teams send personal cards with selectable handwriting, stationery, and tracking.
- [Inblog](https://composio.dev/toolkits/inblog) - Inblog is an AI-powered blogging platform for posts, authors, tags, redirects, design settings, analytics, and lead forms. Use it to manage SEO-focused content, measure performance, and capture blog leads in one place.
- [Instantly](https://composio.dev/toolkits/instantly) - Instantly is a platform for automating cold email outreach, managing leads, and optimizing deliverability. Get better results from email campaigns with minimal manual effort.
- [Invalid Bounce](https://composio.dev/toolkits/invalid_bounce) - Invalid Bounce is an email verification service with a bulk verification API. Use it to clean email lists, reduce bounces, and protect sender reputation.
- [Keyword](https://composio.dev/toolkits/keyword) - Keyword.com is a digital marketing platform for search rank tracking and SEO analytics. Use it to monitor keyword performance, spot ranking changes, and measure SEO visibility.

## Frequently Asked Questions

### What are the differences in Tool Router MCP and Campaign cleaner MCP?

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

### Can I use Tool Router MCP with LangChain?

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 Campaign cleaner tools.

### Can I manage the permissions and scopes for Campaign cleaner while using Tool Router?

Yes, absolutely. You can configure which Campaign cleaner 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.

### How safe is my data with Composio Tool Router?

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 Campaign cleaner data and credentials are handled as safely as possible.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)