Quip MCP Server (TypeScript)
About
A Model Context Protocol (MCP) server for fetching Quip documents, featuring support for both stdio and streamable HTTP transports. It offers native deployment to AWS serverless stacks and AgentCore.
Details
- License
- MIT
Explore
- Retrieve spreadsheet content from Quip documents
- Support for selecting specific sheets by name
- Returns data in CSV format with metadata
- Handles authentication via Quip API token
- Provides appropriate error messages for non-spreadsheet documents
- Automatically handles large spreadsheets by truncating content when necessary
- Stores spreadsheet content locally for efficient access
- Multiple storage options including local filesystem and Amazon S3
- Provides resource URIs for accessing complete spreadsheet content
- Enhanced error handling with detailed error messages and proper error types
- Mock mode for testing without a real Quip API token
- Structured logging with different log levels (debug, info, warn, error)
- API key authentication for securing the HTTP server
- Caching mechanism for improved performance with frequently accessed resources
- Health check endpoint for monitoring server status
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
Quip MCP Server (TypeScript)Command (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Deploy to AWS with zero infrastructure management and pay only for what you use!
npm install -g @zxkane/quip-mcp-server
npm install @zxkane/quip-mcp-server
npm install
Create a .env file in the root directory with your Quip API token:
PORT=3000 HOST=localhost npm start
Add to your Claude settings:
"mcpServers": {
"quip": {
"command": "node",
"args": ["dist/index.js", "--storage-path", "/path/to/storage"],
"env": {
"QUIP_TOKEN": "your_quip_api_token"
}
}
}
If you want to use the file protocol for resource URIs:
"mcpServers": {
"quip": {
"command": "node",
"args": ["dist/index.js", "--storage-path", "/path/to/storage", "--file-protocol"],
"env": {
"QUIP_TOKEN": "your_quip_api_token"
}
}
}
The Quip MCP server can be deployed to AWS Lambda with API Gateway to create a serverless, scalable HTTP endpoint. This setup is ideal for production environments and provides several benefits:
- Serverless Operation: No need to manage servers
- Auto-scaling: Handles varying loads automatically
- High Availability: Distributed across multiple availability zones
- Cost-effective: Pay only for what you use
- Streamable HTTP Interface: Works with tools that support HTTP MCP servers
For detailed deployment instructions, see the Cloud Deployment section.
The server supports API key authentication for securing the HTTP server. When enabled, clients must include the API key in the request headers.
To enable authentication, use the --auth command line argument or set the MCP_AUTH_ENABLED environment variable to true. You can specify the API key using the --api-key argument or MCP_API_KEY environment variable. If not provided, a random API key will be generated and displayed in the logs.
The API key header name can be customized using the --api-key-header argument or MCP_API_KEY_HEADER environment variable. By default, the header name is X-API-Key.
Authentication is only applied to the HTTP transport mode and does not affect stdio transport, which is typically used in more controlled environments.
STORAGE_TYPE=local QUIP_STORAGE_PATH=/path/to/storage npm start
```bash
npm install -g @modelcontextprotocol/inspector
To add new tools:
1. Define the tool in src/tools.ts by adding it to the getQuipTools() function:
export function getQuipTools(): Tool[] {
return [
{
name: "quip_read_spreadsheet",
description: "Read the content of a Quip spreadsheet...",
inputSchema: {
// Schema definition
}
},
{
name: "your_new_tool",
description: "Description of your new tool",
inputSchema: {
// Schema definition for your tool
}
}
];
}
2. Implement the handler function for the tool:
export async function handleYourNewTool(
args: Record<string, any>,
storage: StorageInterface
): Promise<(TextContent | ImageContent | EmbeddedResource)[]> {
// Implement your tool logic here
return [{ type: "text", text: "Your tool response" }];
}
3. Register the handler in src/server.ts by adding it to the call_tool handler:
server.call_tool(async (name: string, arguments_: any) => {
logger.info(Handling tool call: ${name});
logger.debug(Tool arguments: ${JSON.stringify(arguments_)});
if (!arguments_ || typeof arguments_ !== 'object') {
logger.error("Invalid arguments: not an object");
throw new InvalidParamsError("Invalid arguments");
}
try {
if (name === "quip_read_spreadsheet") {
if (!storageInstance) {
throw new StorageError("Storage not initialized");
}
return await handleQuipReadSpreadsheet(arguments_, storageInstance, options.mock);
} else if (name === "your_new_tool") {
return await handleYourNewTool(arguments_, storageInstance);
} else {
logger.error(Unknown tool: ${name});
throw new MethodNotFoundError(Unknown tool: ${name});
}
} catch (error) {
if (error instanceof QuipMCPError) {
throw error;
}
const errorMessage = error instanceof Error ? error.message : String(error);
logger.error(Tool call failed: ${errorMessage});
throw new QuipApiError(Tool call failed: ${errorMessage});
}
});
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"quip mcp server (typescript)": {
"quip-mcp-server-typescript": {
"command": "node",
"args": [
"dist/index.js",
"--storage-path",
"/path/to/storage"
]
}
}
}
}McpServers
{
"quip-mcp-server-typescript": {
"command": "node",
"args": [
"dist/index.js",
"--storage-path",
"/path/to/storage"
]
}
}A Model Context Protocol (MCP) server for interacting with Quip spreadsheets, implemented in TypeScript. This server provides tools to read spreadsheet data from Quip documents and return the content in CSV format.
🚀 AWS Pay-as-You-Go Serverless Deployment
Deploy to AWS with zero infrastructure management and pay only for what you use!
⚡ AWS Agent Core Runtime (Recommended)
- 🔧 SSE Support: Built-in Server-Sent Events for real-time streaming - ⏱️ Extended Runtime: Up to 8 hours execution time - 📦 Large Payloads: 100MB payload support - 🔐 Built-in Auth: Integrated OAuth and identity management - 💰 Consumption-based: Pay only for actual runtime usagecd infrastructure/agent-core
./deploy.sh --agent-name my-quip-mcp --secret-arn arn:aws:secretsmanager:...
🌐 AWS Lambda + API Gateway
- 📈 Auto-scaling: Handles varying loads automatically - 🌍 Global: Distributed across multiple availability zones - 💸 Cost-effective: Pay per request with generous free tier - 🔌 HTTP Interface: Works with any HTTP MCP clientcd infrastructure/api-gateway-lambda
./deploy.sh --secret-arn arn:aws:secretsmanager:...
Both options provide enterprise-grade serverless infrastructure with no servers to manage!
Table of Contents
- Features
- Installation
- Using npm
- From Source
- Environment Variables
- Usage
- Running the Server
- Transport Documentation
- Configure for Claude.app
- Command Line Arguments
- Server-Sent Events (SSE) Support
- Deploy to AWS Lambda + API Gateway
- Available Tools
- quip_read_spreadsheet
- Resource URIs
- How It Works
- Error Handling
- Mock Mode
- Structured Logging
- Authentication
- Caching
- Storage Options
- Local Storage
- S3 Storage
- Health Check Endpoint
- Cloud Deployment
- AWS Lambda + API Gateway
- AWS Agent Core Runtime
- Development
- Project Structure
- Setting Up a Development Environment
- Scripts
- Running Tests
- Debugging
- Adding New Tools
- Contributing
- License
Features
- Retrieve spreadsheet content from Quip documents
- Support for selecting specific sheets by name
- Returns data in CSV format with metadata
- Handles authentication via Quip API token
- Provides appropriate error messages for non-spreadsheet documents
- Automatically handles large spreadsheets by truncating content when necessary
- Stores spreadsheet content locally for efficient access
- Multiple storage options including local filesystem and Amazon S3
- Provides resource URIs for accessing complete spreadsheet content
- Enhanced error handling with detailed error messages and proper error types
- Mock mode for testing without a real Quip API token
- Structured logging with different log levels (debug, info, warn, error)
- API key authentication for securing the HTTP server
- Caching mechanism for improved performance with frequently accessed resources
- Health check endpoint for monitoring server status
Installation
Using npm
```bash
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
