# Quip MCP

> Quip MCP connects Quip collaboration data—documents, threads, and spreadsheets—directly to any AI client. Use it to search across all your accessible files instantly, pull historical messages attached to documents, retrieve folder structures, or programmatically update content right within the thread.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** document-collaboration, spreadsheets, team-messaging, content-management, knowledge-base

## Description

This connector brings your real-time work from Quip into your natural workflow. Instead of switching between your IDE and Quip’s browser, your AI agent handles the heavy lifting. You can perform full-text searches across every document in your accessible space, pulling out exactly what you need, whether it's a specific technical specification or an old product requirement. Need context on a document? Your agent can check the attached message threads for feedback without opening the file. The system also lets you pull down the folder hierarchy and even make programmatic changes; you can update content by passing HTML payloads back into specific Quip threads. Connecting through Vinkius allows your AI client to access this entire library of functionality, making it a single source of truth right where you're working.

## Tools

### get_current_user
Retrieves basic profile information for the user who is currently logged in.

### get_thread
Fetches all content and metadata for a specific Quip document or thread ID.

### get_threads
Retrieves the full content of multiple Quip threads when you provide a list of IDs.

### get_recent_threads
Lists documents that have been recently viewed or modified by any user.

### search_threads
Searches across all accessible Quip documents to find content matching your query.

### get_folder
Retrieves the details and metadata for a single Quip folder by its ID.

### get_folders
Fetches information about multiple Quip folders when you provide a list of IDs.

### get_messages
Lists all chat messages or comments that have been attached to a specific thread.

### get_user
Retrieves detailed profile information for any specified Quip user.

### get_contacts
Lists all collaborators and users associated with the currently logged-in account.

### list_blobs
Retrieves a list of embedded files, images, or media blocks inside a document thread.

### edit_document
Updates the content within an existing Quip document using HTML format.

## Prompt Examples

**Prompt:** 
```
Search Quip for documents containing 'Q3 Roadmap'.
```

**Response:** 
```
I ran `search_threads` for 'Q3 Roadmap' and found 2 relevant documents:
1. 'Engineering Q3 Roadmap' (ID: ABC123DEF)
2. 'Design Team Syncs - Q3 Roadmap' (ID: XYZ987JKL)
Would you like me to retrieve the contents of the Engineering thread?
```

**Prompt:** 
```
What documents did I work on recently in Quip?
```

**Response:** 
```
Using `get_recent_threads`, here are your latest documents:
- 'Sprint 44 Retrospective' - Modified today.
- 'Marketing Copy Ideas' - Modified yesterday.
- 'Q3 Budget Tables' - Modified on Tuesday.
```

**Prompt:** 
```
Add a new heading called 'Conclusion' and a paragraph 'All tests passed' to document ABC123DEF.
```

**Response:** 
```
I successfully edited the thread 'ABC123DEF' using the HTML payload: `<h2>Conclusion</h2><p>All tests passed</p>`. The content has been added to the document.
```

## Capabilities

### Search all documents
Perform full-text searches across every document in your Quip workspace.

### Retrieve thread details
Fetch the complete content of a single Quip document or thread using its unique ID.

### List recent work
See a list of documents you or your team have recently viewed or edited.

### View conversation history
Check all messages and comments attached to any given document thread.

### Edit content
Programmatically update existing Quip documents by sending new HTML-formatted text payloads.

## Use Cases

### Finding buried requirements
A dev needs to know if a feature was discussed last month. They ask their agent: 'Search Quip for documents containing 'API rate limits'.' The agent runs `search_threads`, finds the document, and pulls the relevant text right into your chat.

### Client update drafting
An AE has finalized talking points. They use their agent to run `edit_document` on a shared Quip file, pushing the polished HTML version directly into the document for immediate client viewing.

### Catching up on project status
A PM returns from vacation and asks: 'What were the last 10 things I looked at in Quip?' The agent uses `get_recent_threads` to give an instant list of modified documents, skipping the manual folder browse.

### Deep dive on a topic
A team member needs all comments around a key decision. They tell their agent to check the thread and run `get_messages` for that ID, gathering every piece of feedback in one place.

## Benefits

- Context is always available. If you need to know what was discussed about the 'Q3 Roadmap,' simply ask your agent to search using `search_threads`, pulling in relevant discussions instantly.
- Stop wasting time on outdated info. By running `get_recent_threads`, your agent immediately gives you a list of documents you or your team worked on, so you never lose context.
- You can update content directly from the chat. Using `edit_document` means you don't have to manually open Quip and copy/paste; you just send the final HTML payload.
- Get granular details about a document. Need everything in one place? Use `get_thread` or `list_blobs` to pull out all attached messages, files, and core text together.
- Manage your workspace structure. Instead of navigating manually, use `get_folders` to batch-fetch multiple folder IDs, giving you a map of the entire Quip library.

## How It Works

The bottom line is that your AI agent treats Quip like another API endpoint, allowing you to interact with its content using natural conversation rather than manual clicks.

1. Subscribe to the MCP and authorize it using your Quip Personal Access Token.
2. Instruct your AI agent to perform an action, like searching for a document or summarizing comments attached to a thread.
3. Your AI client executes the necessary commands and returns the requested data—whether it's raw text, file lists, or structured metadata.

## Frequently Asked Questions

**How do I securely obtain my Quip Access Token?**
Sign in to your Quip account. Navigate to your API token generator page (usually at `platform.quip.com` or via Quip's Developer Settings). Generate a **Personal Access Token**, copy the string, and securely save it in the configuration fields below.

**Can I provide a Quip document URL to my AI, or just the ID?**
You can provide the standard URL. The agent is capable of recognizing the URL structure, extracting the alphanumeric `thread_id`, and performing the operation accurately.

**Can it read embedded images or files inside the document?**
The agent detects their existence by reading the raw structure and uses `list_blobs` to catalog attachments. However, downloading the actual files depends on your client's supported capabilities.

**Is the edit operation destructive?**
The `edit_document` function uses Quip's native append logic to add new HTML blocks at the end of the document, mitigating complete overwrites. Additionally, Quip maintains a full version history allowing rollbacks if necessary.