How to integrate Google Docs MCP with OpenAI Agents SDK

This guide walks you through connecting Google Docs to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Google Docs agent that can create a new meeting notes document, copy last week's project summary template, add bullet points to the action items section through natural language commands. This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Google Docs account through Composio's Google Docs MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Google Docs logoGoogle Docs
Oauth2

Google Docs is a cloud-based word processor that enables document creation and real-time collaboration. Its seamless sharing and version history make team editing and content management a breeze.

33 Tools10 Triggers

Introduction

This guide walks you through connecting Google Docs to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Google Docs agent that can create a new meeting notes document, copy last week's project summary template, add bullet points to the action items section through natural language commands.

This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Google Docs account through Composio's Google Docs MCP server.

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

Also integrate Google Docs with

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Google Docs
  • Configure an AI agent that can use Google Docs as a tool
  • Run a live chat session where you can ask the agent to perform Google Docs operations

What is OpenAI Agents SDK?

The OpenAI Agents SDK is a lightweight framework for building AI agents that can use tools and maintain conversation state. It provides a simple interface for creating agents with hosted MCP tool support.

Key features include:

  • Hosted MCP Tools: Connect to external services through hosted MCP endpoints
  • SQLite Sessions: Persist conversation history across interactions
  • Simple API: Clean interface with Agent, Runner, and tool configuration
  • Streaming Support: Real-time response streaming for interactive applications

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

The Google Docs 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 Docs account. It provides structured and secure access to your documents, so your agent can create, copy, edit, and organize Google Docs on your behalf.

  • Automated document creation and duplication: Let your agent generate new Google Docs from scratch or copy existing documents to quickly use templates or preserve originals.
  • Rich content editing and formatting: Direct your agent to add headers, footers, footnotes, bullet lists, and more—making it easy to update and format documents programmatically.
  • Targeted content manipulation: Have your agent delete specific content ranges, paragraphs, or sections within any document to keep your files up to date.
  • Named range management: Empower your agent to create and manage named ranges for easier referencing, collaboration, and advanced document workflows.
  • Markdown-based document generation: Allow the agent to create new Google Docs directly from markdown content, streamlining content migration from other tools or sources.

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 step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and OpenAI API Key
  • Primary know-how of OpenAI Agents SDK
  • A live Google Docs project
  • Some knowledge of Python or Typescript
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
3

Install dependencies

npm install @composio/openai-agents @openai/agents dotenv

Install the Composio SDK and the OpenAI Agents SDK.

4

Set up environment variables

bash
OPENAI_API_KEY=sk-...your-api-key
COMPOSIO_API_KEY=your-api-key
USER_ID=composio_user@gmail.com

Create a .env file and add your OpenAI and Composio API keys.

5

Import dependencies

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';
What's happening:
  • You're importing all necessary libraries.
  • The Composio and OpenAIAgentsProvider classes are imported to connect your OpenAI agent to Composio tools like Google Docs.
6

Set up the Composio instance

dotenv.config();

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

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});
What's happening:
  • dotenv.config() loads your .env file so COMPOSIO_API_KEY and USER_ID are available as environment variables.
  • Creating a Composio instance using the API Key and OpenAIAgentsProvider class.
7

Create a Tool Router session

// Create Tool Router session for Google Docs
const session = await composio.create(userId as string, {
  toolkits: ['googledocs'],
});
const mcpUrl = session.mcp.url;

What is happening:

  • You give the Tool Router the user id and the toolkits you want available. Here, it is only googledocs.
  • The router checks the user's Google Docs connection and prepares the MCP endpoint.
  • The returned session.mcp.url is the MCP URL that your agent will use to access Google Docs.
  • This approach keeps things lightweight and lets the agent request Google Docs tools only when needed during the conversation.
8

Configure the agent

// Configure agent with MCP tool
const agent = new Agent({
  name: 'Assistant',
  model: 'gpt-5',
  instructions:
    'You are a helpful assistant that can access Google Docs. Help users perform Google Docs operations through natural language.',
  tools: [
    hostedMcpTool({
      serverLabel: 'tool_router',
      serverUrl: mcpUrl,
      headers: { 'x-api-key': composioApiKey },
      requireApproval: 'never',
    }),
  ],
});
What's happening:
  • We're creating an Agent instance with a name, model (gpt-5), and clear instructions about its purpose.
  • The agent's instructions tell it that it can access Google Docs and help with queries, inserts, updates, authentication, and fetching database information.
  • The tools array includes a hostedMcpTool that connects to the MCP server URL we created earlier.
  • The headers object includes the Composio API key for secure authentication with the MCP server.
  • requireApproval: 'never' means the agent can execute Google Docs operations without asking for permission each time, making interactions smoother.
9

Start chat loop and handle conversation

// Keep conversation state across turns
const conversationSession = new OpenAIConversationsSession();

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

console.log('\nComposio Tool Router session created.');
console.log('\nChat started. Type your requests below.');
console.log("Commands: 'exit', 'quit', or 'q' to end\n");

try {
  const first = await run(agent, 'What can you help me with?', { session: conversationSession });
  console.log(`Assistant: ${first.finalOutput}\n`);
} catch (e) {
  console.error('Error:', e instanceof Error ? e.message : e, '\n');
}

rl.prompt();

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

  if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
    console.log('Goodbye!');
    rl.close();
    process.exit(0);
  }

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

  try {
    const result = await run(agent, text, { session: conversationSession });
    console.log(`\nAssistant: ${result.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();
});

rl.on('close', () => {
  console.log('\n👋 Session ended.');
  process.exit(0);
});
What's happening:
  • The program prints a session URL that you visit to authorize Google Docs.
  • After authorization, the chat begins.
  • Each message you type is processed by the agent using run().
  • The responses are printed to the console.
  • Typing exit, quit, or q cleanly ends the chat.

Complete Code

Here's the complete code to get you started with Google Docs and OpenAI Agents SDK:

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';

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

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});

async function main() {
  // Create Tool Router session
  const session = await composio.create(userId as string, {
    toolkits: ['googledocs'],
  });
  const mcpUrl = session.mcp.url;

  // Configure agent with MCP tool
  const agent = new Agent({
    name: 'Assistant',
    model: 'gpt-5',
    instructions:
      'You are a helpful assistant that can access Google Docs. Help users perform Google Docs operations through natural language.',
    tools: [
      hostedMcpTool({
        serverLabel: 'tool_router',
        serverUrl: mcpUrl,
        headers: { 'x-api-key': composioApiKey },
        requireApproval: 'never',
      }),
    ],
  });

  // Keep conversation state across turns
  const conversationSession = new OpenAIConversationsSession();

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

  console.log('\nComposio Tool Router session created.');
  console.log('\nChat started. Type your requests below.');
  console.log("Commands: 'exit', 'quit', or 'q' to end\n");

  try {
    const first = await run(agent, 'What can you help me with?', { session: conversationSession });
    console.log(`Assistant: ${first.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();

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

    if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
      console.log('Goodbye!');
      rl.close();
      process.exit(0);
    }

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

    try {
      const result = await run(agent, text, { session: conversationSession });
      console.log(`\nAssistant: ${result.finalOutput}\n`);
    } catch (e) {
      console.error('Error:', e instanceof Error ? e.message : e, '\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

This was a starter code for integrating Google Docs MCP with OpenAI Agents SDK to build a functional AI agent that can interact with Google Docs.

Key features:

  • Hosted MCP tool integration through Composio's Tool Router
  • SQLite session persistence for conversation history
  • Simple async chat loop for interactive testing
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS & TRIGGERS

Supported Tools and Triggers

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

Copy Google Document

Tool to create a copy of an existing Google Document.

Create a document

Creates a new Google Docs document using the provided title as filename and inserts the initial text at the beginning if non-empty, returning the document's ID and metadata (excluding body content).

Create Document Markdown

Creates a new Google Docs document, optionally initializing it with a title and content provided as Markdown text.

Create Footer

Tool to create a new footer in a Google Document.

Create Footnote

Tool to create a new footnote in a Google Document.

Create Header

Tool to create a new header in a Google Document, optionally with text content.

Create Named Range

Tool to create a new named range in a Google Document.

Create Paragraph Bullets

Tool to add bullets to paragraphs within a specified range in a Google Document.

Delete Content Range in Document

Tool to delete a range of content from a Google Document.

Delete Footer

Tool to delete a footer from a Google Document.

Delete Header

Deletes the header from the specified section or the default header if no section is specified.

Delete Named Range

Tool to delete a named range from a Google Document.

Delete Paragraph Bullets

Tool to remove bullets from paragraphs within a specified range in a Google Document.

Delete Table Column

Tool to delete a column from a table in a Google Document.

Delete Table Row

Tool to delete a row from a table in a Google Document.

Export Google Doc as PDF

Tool to export a Google Docs file as PDF using the Google Drive API.

Get document by id

Retrieves an existing Google Document by its ID; will error if the document is not found.

Get document plain text

Retrieve a Google Doc by ID and return a best-effort plain-text rendering.

Insert Inline Image

Tool to insert an image from a given URI at a specified location in a Google Document as an inline image.

Insert Page Break

Tool to insert a page break into a Google Document.

Insert Table in Google Doc

Tool to insert a table into a Google Document.

Insert Table Column

Tool to insert a new column into a table in a Google Document.

Insert Text into Document

Tool to insert a string of text at a specified location within a Google Document.

Get Charts from Spreadsheet

Tool to retrieve a list of all charts from a specified Google Sheets spreadsheet.

Replace All Text in Document

Tool to replace all occurrences of a specified text string with another text string throughout a Google Document.

Replace Image in Document

Tool to replace a specific image in a document with a new image from a URI.

Search Documents

Search for Google Documents using various filters including name, content, date ranges, and more.

Unmerge Table Cells

Tool to unmerge previously merged cells in a table.

Update Document Markdown

Replaces the entire content of an existing Google Docs document with new Markdown text; requires edit permissions for the document.

Update Document Section Markdown

Tool to insert or replace a section of a Google Docs document with Markdown content.

Update Document Style

Tool to update the overall document style, such as page size, margins, and default text direction.

Update existing document

Applies programmatic edits, such as text insertion, deletion, or formatting, to a specified Google Doc using the `batchUpdate` API method.

Update Table Row Style

Tool to update the style of a table row in a Google Document.

FAQ

Frequently asked questions

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

Yes, you can. OpenAI Agents SDK 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 Docs tools.

Yes, absolutely. You can configure which Google Docs 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 Google Docs data and credentials are handled as safely as possible.

Start with Google Docs.It takes 30 seconds.

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

Start building