# How to integrate Google Tasks MCP with LangChain ```json { "title": "How to integrate Google Tasks MCP with LangChain", "toolkit": "Google Tasks", "toolkit_slug": "googletasks", "framework": "LangChain", "framework_slug": "langchain", "url": "https://composio.dev/toolkits/googletasks/framework/langchain", "markdown_url": "https://composio.dev/toolkits/googletasks/framework/langchain.md", "updated_at": "2026-10-12T13:39:00.391Z" } ``` ## Introduction This guide walks you through connecting Google Tasks to LangChain using the Composio tool router. By the end, you'll have a working Google Tasks agent that can add a new task to your work list, list all tasks due this week, delete completed tasks from your shopping list through natural language commands. This guide will help you understand how to give your LangChain agent real control over a Google Tasks account through Composio's Google Tasks MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved. ## Also integrate Google Tasks with - [Claude Code](https://composio.dev/toolkits/googletasks/framework/claude-code) - [Cursor](https://composio.dev/toolkits/googletasks/framework/cursor) - [ChatGPT](https://composio.dev/toolkits/googletasks/framework/chatgpt) - [Claude Cowork](https://composio.dev/toolkits/googletasks/framework/claude-cowork) - [Antigravity](https://composio.dev/toolkits/googletasks/framework/antigravity) - [OpenAI Agents SDK](https://composio.dev/toolkits/googletasks/framework/open-ai-agents-sdk) - [Claude Agent SDK](https://composio.dev/toolkits/googletasks/framework/claude-agents-sdk) - [Grok Bot](https://composio.dev/toolkits/googletasks/framework/grok-bot) - [Muse](https://composio.dev/toolkits/googletasks/framework/muse) - [Codex](https://composio.dev/toolkits/googletasks/framework/codex) - [Kimi Code](https://composio.dev/toolkits/googletasks/framework/kimi) - [Grok Build](https://composio.dev/toolkits/googletasks/framework/grok-build) - [VS Code](https://composio.dev/toolkits/googletasks/framework/vscode) - [OpenCode](https://composio.dev/toolkits/googletasks/framework/opencode) - [OpenClaw](https://composio.dev/toolkits/googletasks/framework/openclaw) - [Hermes](https://composio.dev/toolkits/googletasks/framework/hermes-agent) - [Atomic Agent](https://composio.dev/toolkits/googletasks/framework/atomic-agent) - [CLI](https://composio.dev/toolkits/googletasks/framework/cli) - [Google ADK](https://composio.dev/toolkits/googletasks/framework/google-adk) - [Vercel AI SDK](https://composio.dev/toolkits/googletasks/framework/ai-sdk) - [Mastra AI](https://composio.dev/toolkits/googletasks/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/googletasks/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/googletasks/framework/crew-ai) - [Pydantic AI](https://composio.dev/toolkits/googletasks/framework/pydantic-ai) - [AutoGen](https://composio.dev/toolkits/googletasks/framework/autogen) ## TL;DR Here's what you'll learn: - Get and set up your OpenAI and Composio API keys - Connect your Google Tasks project to Composio - Create a Tool Router MCP session for Google Tasks - Initialize an MCP client and retrieve Google Tasks tools - Build a LangChain agent that can interact with Google Tasks - 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 Google Tasks MCP server, and what's possible with it? The Google Tasks MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Google Tasks account. It provides structured and secure access to your task lists and tasks, so your agent can create, retrieve, update, move, and delete them on your behalf. - Task creation and planning: Have your agent create tasks, add subtasks, and place new work in the right task list. - Task retrieval and review: Instruct your agent to retrieve a specific task, review tasks from one list, or list tasks across all your lists using completion and date filters. - Task updates and organization: Let the agent edit task details or move tasks to a different position or task list as your plans change. - Task list management: Direct your agent to create, retrieve, rename, or permanently delete task lists. - Completed task cleanup: Have your agent delete individual tasks or permanently clear completed tasks from a chosen list. ## Supported Tools | Tool slug | Name | Description | |---|---|---| | `GOOGLETASKS_BATCH_EXECUTE` | Batch Execute Google Tasks Operations | Executes multiple Google Tasks API operations in a single HTTP batch request and returns structured per-item results. Use this to reduce LLM tool invocations when performing bulk operations like updating many tasks, moving tasks, or deleting multiple items. Note: Each sub-request still counts toward API quota; batching primarily reduces HTTP overhead and tool call count. | | `GOOGLETASKS_CLEAR_TASKS` | Clear tasks | Permanently and irreversibly clears all completed tasks from a specified Google Tasks list; this action is destructive, idempotent, and cannot be undone. Always require explicit user confirmation before invoking. | | `GOOGLETASKS_CREATE_TASK_LIST` | Create a task list | Creates a new task list with the specified title and returns a tasklist_id. Use the returned tasklist_id (not the title) when calling GOOGLETASKS_INSERT_TASK or other task operations. Duplicate titles are permitted by the API, so verify existing lists before creating to avoid unintended duplicates. | | `GOOGLETASKS_DELETE_TASK` | Delete task | Deletes a specified task from a Google Tasks list. Deletion is permanent and irreversible — confirm with the user before executing, and consider GOOGLETASKS_UPDATE_TASK or GOOGLETASKS_MOVE_TASK as non-destructive alternatives. Both tasklist_id and task_id are required parameters. The Google Tasks API does not support deleting tasks by task_id alone — you must specify which task list contains the task. Use 'List Task Lists' to get available list IDs, then 'List Tasks' to find the task_id within that list. | | `GOOGLETASKS_DELETE_TASK_LIST` | Delete task list | Permanently deletes an existing Google Task list, identified by `tasklist_id`, along with all its tasks; this operation is irreversible. Require explicit user confirmation before calling; do not invoke in read-only or exploratory flows. | | `GOOGLETASKS_GET_TASK` | Get Task | Retrieve a specific Google Task. REQUIRES both `tasklist_id` and `task_id`. Tasks cannot be retrieved by ID alone - you must always specify which task list contains the task. Use this to refresh task details before display or edits rather than relying on potentially stale results from GOOGLETASKS_LIST_TASKS. | | `GOOGLETASKS_GET_TASK_LIST` | Get task list | Retrieves a specific task list from the user's Google Tasks if the `tasklist_id` exists for the authenticated user. | | `GOOGLETASKS_INSERT_TASK` | Insert Task | Creates a new task in a given `tasklist_id`, optionally as a subtask of an existing `task_parent` or positioned after an existing `task_previous` sibling, where both `task_parent` and `task_previous` must belong to the same `tasklist_id` if specified. IMPORTANT: Date fields (due, completed) accept various formats like '28 Sep 2025', '11:59 PM, 22 Sep 2025', or ISO format '2025-09-21T15:30:00Z' and will automatically convert them to RFC3339 format required by the API. Not idempotent — repeated calls with identical parameters create duplicate tasks; track returned task IDs to avoid duplication. High-volume inserts may trigger 403 rateLimitExceeded or 429; apply exponential backoff. | | `GOOGLETASKS_LIST_ALL_TASKS` | List All Tasks Across All Lists | Tool to list all tasks across all of the user's task lists with optional filters. Use when the agent needs to see all tasks without knowing which list to query first. Each returned task is annotated with its tasklist_id and tasklist_title for context. | | `GOOGLETASKS_LIST_TASK_LISTS` | List task lists | Fetches the authenticated user's task lists from Google Tasks; results may be paginated. Response contains task lists under the `items` key. Multiple lists may share similar names — confirm the correct list by ID before passing to other tools. | | `GOOGLETASKS_LIST_TASKS` | List Tasks | Retrieves tasks from a Google Tasks list; all date/time strings must be RFC3339 UTC, and `showCompleted` must be true if `completedMin` or `completedMax` are specified. Response key for tasks is `tasks` (not `items`). No full-text search; filter client-side by title/notes. Results ordered by position, not by date. | | `GOOGLETASKS_MOVE_TASK` | Move Task | Moves the specified task to another position in the task list or to a different task list. Use cases: - Reorder tasks within a list (use 'previous' parameter) - Create subtasks by moving a task under a parent (use 'parent' parameter) - Move tasks between different task lists (use 'destinationTasklist' parameter) - Move a subtask back to top-level (omit 'parent' parameter) | | `GOOGLETASKS_PATCH_TASK` | Patch Task | Partially updates an existing task (identified by `task_id`) within a specific Google Task list (identified by `tasklist_id`), modifying only the provided attributes from `TaskInput` (e.g., `title`, `notes`, `due` date, `status`) and requiring both the task and list to exist. | | `GOOGLETASKS_PATCH_TASK_LIST` | Patch task list | Updates the title of an existing Google Tasks task list. | | `GOOGLETASKS_UPDATE_TASK_FULL` | Update Task (Full Replacement) | Tool to fully replace an existing Google Task using PUT method. Use when you need to update the entire task resource, not just specific fields. This method requires all required fields (id, title) and replaces the complete task, unlike PATCH which supports partial updates. | | `GOOGLETASKS_UPDATE_TASK_LIST` | Update Task List | Updates the authenticated user's specified task list. | ## Supported Triggers | Trigger slug | Name | Description | |---|---|---| | `GOOGLETASKS_NEW_TASK_CREATED_TRIGGER` | New Task Created | Triggers when a new task is created in a Google Tasks list. Uses timestamp filtering (updatedMin) to efficiently detect new tasks. | | `GOOGLETASKS_NEW_TASK_LIST_CREATED_TRIGGER` | New Task List Created | Triggers when a new Google Tasks task list is created. This trigger monitors Google Tasks and fires when new task lists are detected. | | `GOOGLETASKS_TASK_DETAILS_CHANGED_TRIGGER` | Task Details Changed | Triggers when a specific task's details change. This trigger monitors a single Google Task and fires when any of its details (title, notes, status, due date, completion, position) are modified. | | `GOOGLETASKS_TASK_LIST_CHANGED_TRIGGER` | Task List Changed | Triggers when a task list changes (title or content updates). This trigger monitors a specific Google Tasks list and fires when changes are detected. | | `GOOGLETASKS_TASK_UPDATED_TRIGGER` | Task Updated | Triggers when an existing task is updated in a Google Tasks list. This trigger monitors a specific task list and fires when tasks are modified. | ## Creating MCP Server - Stand-alone vs Composio SDK The Google Tasks MCP server is an implementation of the Model Context Protocol that connects your AI agent to Google Tasks. It provides structured and secure access so your agent can perform Google Tasks 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 Google Tasks 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 Google Tasks 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 Google Tasks tools as needed ```python # Create Tool Router session for Google Tasks session = composio.create( user_id=os.getenv("COMPOSIO_USER_ID"), toolkits=['googletasks'] ) url = session.mcp.url ``` ```typescript const session = await composio.create( userId as string, { toolkits: ['googletasks'] } ); const url = session.mcp.url; ``` ### 7. Configure the agent with the MCP URL No description provided. ```python client = MultiServerMCPClient({ "googletasks-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({ "googletasks-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 Google Tasks 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 Google Tasks 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=['googletasks'] ) url = session.mcp.url client = MultiServerMCPClient({ "googletasks-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 Google Tasks 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: ['googletasks'] } ); const url = session.mcp.url; const client = new MultiServerMCPClient({ "googletasks-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 Google Tasks 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 Google Tasks 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 Google Tasks MCP Agent with another framework - [Claude Code](https://composio.dev/toolkits/googletasks/framework/claude-code) - [Cursor](https://composio.dev/toolkits/googletasks/framework/cursor) - [ChatGPT](https://composio.dev/toolkits/googletasks/framework/chatgpt) - [Claude Cowork](https://composio.dev/toolkits/googletasks/framework/claude-cowork) - [Antigravity](https://composio.dev/toolkits/googletasks/framework/antigravity) - [OpenAI Agents SDK](https://composio.dev/toolkits/googletasks/framework/open-ai-agents-sdk) - [Claude Agent SDK](https://composio.dev/toolkits/googletasks/framework/claude-agents-sdk) - [Grok Bot](https://composio.dev/toolkits/googletasks/framework/grok-bot) - [Muse](https://composio.dev/toolkits/googletasks/framework/muse) - [Codex](https://composio.dev/toolkits/googletasks/framework/codex) - [Kimi Code](https://composio.dev/toolkits/googletasks/framework/kimi) - [Grok Build](https://composio.dev/toolkits/googletasks/framework/grok-build) - [VS Code](https://composio.dev/toolkits/googletasks/framework/vscode) - [OpenCode](https://composio.dev/toolkits/googletasks/framework/opencode) - [OpenClaw](https://composio.dev/toolkits/googletasks/framework/openclaw) - [Hermes](https://composio.dev/toolkits/googletasks/framework/hermes-agent) - [Atomic Agent](https://composio.dev/toolkits/googletasks/framework/atomic-agent) - [CLI](https://composio.dev/toolkits/googletasks/framework/cli) - [Google ADK](https://composio.dev/toolkits/googletasks/framework/google-adk) - [Vercel AI SDK](https://composio.dev/toolkits/googletasks/framework/ai-sdk) - [Mastra AI](https://composio.dev/toolkits/googletasks/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/googletasks/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/googletasks/framework/crew-ai) - [Pydantic AI](https://composio.dev/toolkits/googletasks/framework/pydantic-ai) - [AutoGen](https://composio.dev/toolkits/googletasks/framework/autogen) ## Related Toolkits - [Google Sheets](https://composio.dev/toolkits/googlesheets) - Google Sheets is a cloud-based spreadsheet tool for real-time collaboration and data analysis. It lets teams work together from anywhere, updating information instantly. - [Notion](https://composio.dev/toolkits/notion) - Notion is a collaborative workspace for notes, docs, wikis, and tasks. It streamlines team knowledge, project tracking, and workflow customization in one place. - [Airtable](https://composio.dev/toolkits/airtable) - Airtable combines the flexibility of spreadsheets with the power of a database for easy project and data management. Teams use Airtable to organize, track, and collaborate with custom views and automations. - [Asana](https://composio.dev/toolkits/asana) - Asana is a collaborative work management platform for teams to organize and track projects. It streamlines teamwork, boosts productivity, and keeps everyone aligned on goals. - [Linear](https://composio.dev/toolkits/linear) - Linear is a modern issue tracking and project planning tool for fast-moving teams. It helps streamline workflows, organize projects, and boost productivity. - [Jira](https://composio.dev/toolkits/jira) - Jira is Atlassian’s platform for bug tracking, issue tracking, and agile project management. It helps teams organize work, prioritize tasks, and deliver projects efficiently. - [Clickup](https://composio.dev/toolkits/clickup) - ClickUp is an all-in-one productivity platform for managing tasks, docs, goals, and team collaboration. It streamlines project workflows so teams can work smarter and stay organized in one place. - [Monday](https://composio.dev/toolkits/monday) - Monday.com is a customizable work management platform for project planning and collaboration. It helps teams organize tasks, automate workflows, and track progress in real time. - [Addressfinder](https://composio.dev/toolkits/addressfinder) - Addressfinder is a data quality platform for verifying addresses, emails, and phone numbers. It helps you ensure accurate customer and contact data every time. - [Agiled](https://composio.dev/toolkits/agiled) - Agiled is an all-in-one business management platform for CRM, projects, and finance. It helps you streamline workflows, consolidate client data, and manage business processes in one place. - [AirOps MCP](https://composio.dev/toolkits/airops_mcp) - AirOps MCP is AirOps' managed content platform exposing brand context, knowledge bases, and workflows. Use it to give agents brand-aware content, automate content workflows, and track Brand Kit edits. - [Amazing Marvin](https://composio.dev/toolkits/amazing_marvin) - Amazing Marvin is a personal productivity app for tasks, projects, habits, planning, time tracking, and rewards. It helps you build a flexible workflow that matches how you actually work. - [AnyDB](https://composio.dev/toolkits/any_db) - AnyDB is a flexible collaborative database platform for organizing records, files, and automated workflows. It helps teams centralize data, collaborate on records, and automate routine tasks. - [ApptiveGrid](https://composio.dev/toolkits/apptivegrid) - ApptiveGrid is a collaborative no-code database and app platform for spaces, grids, forms, and structured records. It helps teams organize operational data, collect inputs, and build lightweight business apps without custom backend work. - [Ascora](https://composio.dev/toolkits/ascora) - Ascora is a cloud-based field service management platform for service businesses. It streamlines scheduling, invoicing, and customer operations in one place. - [Atlassian MCP](https://composio.dev/toolkits/atlassian_mcp) - Atlassian Rovo MCP connects agents to Jira, Jira Service Management, Confluence, Bitbucket, Compass, and Teamwork Graph workflows. It lets teams surface and act on Atlassian data while respecting existing user permissions. - [Basecamp](https://composio.dev/toolkits/basecamp) - Basecamp is a project management and team collaboration tool by 37signals. It helps teams organize tasks, share files, and communicate efficiently in one place. - [Beeminder](https://composio.dev/toolkits/beeminder) - Beeminder is an online goal-tracking platform that uses monetary pledges to keep you motivated. Stay accountable and hit your targets with real financial incentives. - [Boxhero](https://composio.dev/toolkits/boxhero) - Boxhero is a cloud-based inventory management platform for SMBs, offering real-time updates, barcode scanning, and team collaboration. It helps businesses streamline stock tracking and analytics for smarter inventory decisions. - [Breathe HR](https://composio.dev/toolkits/breathehr) - Breathe HR is cloud-based HR software for SMEs to manage employee data, absences, and performance. It simplifies HR admin, making it easy to keep employee records accurate and up to date. ## Frequently Asked Questions ### What are the differences in Tool Router MCP and Google Tasks MCP? With a standalone Google Tasks MCP server, the agents and LLMs can only access a fixed set of Google Tasks tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Google Tasks 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 Google Tasks tools. ### Can I manage the permissions and scopes for Google Tasks while using Tool Router? Yes, absolutely. You can configure which Google Tasks 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 Google Tasks data and credentials are handled as safely as possible. --- [See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)