# ProductNow MCP

```json
{
  "name": "ProductNow MCP",
  "slug": "productnow_mcp",
  "url": "https://composio.dev/toolkits/productnow_mcp",
  "markdown_url": "https://composio.dev/toolkits/productnow_mcp.md",
  "logo_url": "https://logos.composio.dev/api/productnow_mcp",
  "categories": [
    "document & file management"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-10-23T05:34:25.368Z"
}
```

![ProductNow MCP logo](https://logos.composio.dev/api/productnow_mcp)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with ProductNow MCP or direct API to search company context, manage documents, organize folders, track versions, and handle comments through natural language.

## Summary

ProductNow MCP is an official user-authenticated MCP server for ProductNow company context and content.
It provides a secure, consistent way to access documents, folders, versions, comments, and media.

## Categories

- document & file management

## Toolkit Details

- Tools: 16

## Images

- Logo: https://logos.composio.dev/api/productnow_mcp

## Authentication

- **Dcr Oauth**
  - Type: `custom`
  - Description: Dcr Oauth authentication for ProductNow MCP.
  - Setup:
    - Configure Dcr Oauth credentials for ProductNow MCP.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Search ProductNow company context for launch details
- Organize ProductNow documents into project folders
- Review ProductNow versions and resolve comments

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `PRODUCTNOW_MCP_ARCHIVE` | Archive | Put documents or folders away, including several at once. Pass ids, a mix of document ids and folder ids. Archiving a folder also archives the contents that user can manage. Archived items leave listings and search; nothing is deleted. Not move, and not a content edit — use edit_document to change content. Ids that are not a document or folder here come back in unresolvedIds. Ids the user cannot archive come back in permissionDeniedIds; the rest are still archived. |
| `PRODUCTNOW_MCP_COMMENT_ON_DOCUMENT` | Comment on document | Leave feedback on a document that is in review. Not an edit — use edit_document to change the document, and reply_to_thread to answer an existing comment. Pass documentId; this comments on the current review version and says so when there is none. Posted as the user's personal agent. |
| `PRODUCTNOW_MCP_CREATE_DOCUMENT` | Create document | Create a NEW ProductNow document and generate its content with AI. Use this to persist knowledge the user wants remembered or shared across sessions and teammates — decisions, specs, RFCs, plans, meeting outcomes. Search with search first so you don't duplicate an existing document; to change an existing document use edit_document instead. File the document in an existing folder. Search results include each document's folderId; pass the folderId of the closest related document. If search does not show a fit, fetch_folder the root and walk folders until you have a folderId. Leave folderId off only when the user explicitly asked for the warehouse root. If no folder fits, call create_folder under the closest existing folder and pass that new folderId. Content is generated from `prompt` (the full outline: numbered sections, their titles, and what each should say) and `context` (verbatim source material the user supplied or explicitly authorized for this ProductNow document). Generation paraphrases: if exact wording must survive, put it in `context` and say so in `prompt`. Pass `templateId` only when you already have one. Returns the documentId and URL; generation continues after the call returns. |
| `PRODUCTNOW_MCP_CREATE_FOLDER` | Create folder | Create a NEW folder only when no existing folder fits. Search with search and resultType folders first so you don't duplicate a folder; if that is not enough, fetch_folder the root and walk until you find the closest related folder. Nest under that folder by passing its id as parentFolderId. Omit parentFolderId only when the user explicitly asked for a root-level folder. Returns the new folder's id and name. |
| `PRODUCTNOW_MCP_EDIT_DOCUMENT` | Edit document | Edit an existing ProductNow document. This is the only tool that changes a document's content. It does not apply your edit directly: it hands `message` to the document's own editing agent, which reads the document and makes the change. Write `message` as instructions to that agent, not as the new document text. Name the section, say exactly what to add, replace, or remove, and quote text verbatim when the wording must be preserved. Include everything the agent needs, since it cannot see this conversation and will not ask follow-up questions. Returns before the edit finishes; poll get_status until status is idle (it stays running while any edit you sent is queued or in progress), then read the document to confirm the result. Do not use create_document — that creates a new document. Do not use rename — that only changes a name. Do not use reply_to_thread — that only adds discussion and never changes content. |
| `PRODUCTNOW_MCP_FETCH` | Fetch | Read one document you already have an id for. Pass documentId. The result includes the document's id, title, url, and full text, plus its sections, comment threads, and each comment's id. When the document is filed in a folder, the result includes that folder's folderId and folderName. Omit documentVersionId to read the latest draft; pass one to read that version and its comments. Version ids come from list_document_versions. Not a search — use search for a question or a topic. Not a folder listing — use fetch_folder to list a folder or the warehouse root. |
| `PRODUCTNOW_MCP_FETCH_FOLDER` | Fetch folder | List a folder you already have an id for, or the warehouse root. Pass folderId to list that folder's name, an optional parentFolderId to fetch and go up, and its direct contents. Each child folder and document includes its id, name, updatedAt, createdBy, and isPrivate. Each folder also includes contentCount, its direct documents plus subfolders, and subfolderCount, its direct child folders. Each document also includes its status: DRAFT, REVIEW, or PUBLISHED. A child folder also includes parentFolderId when it is nested, including a shared folder that shows up in the root listing but lives somewhere else; parentFolderId is omitted for a true top-level folder. Pass deep true with a folderId to return that folder and every nested folder as a tree, up to 15 levels, with each folder's documents inside it. deep is rejected for the warehouse root. Omit folderId to list the root one level: the top-level folders plus shared folders this user can see, not the whole warehouse and not other people's private folders. Not a search — use search to find a folder by name. Not a document read — use fetch to read a document. |
| `PRODUCTNOW_MCP_GET_STATUS` | Get status | After edit_document or create_document, check whether the document is still being edited or the edits have finished. Pass documentId. Returns running or idle, and a short note of what the draft agent last did. Use it to poll: after sending one or more edits to the same document, call get_status until status is idle, then fetch the document to confirm the result. Edits queue behind each other, so idle means every edit sent so far has finished, not just the latest one. running means at least one edit is still queued or in progress. Not the chat transcript, and not a way to edit — use edit_document to change the document. |
| `PRODUCTNOW_MCP_LIST_DOCUMENT_VERSIONS` | List document versions | List every version of a document when the user asks what changed, or you need an older version before calling fetch. Pass documentId. Returns each version's id, version number, status, and when it was created, newest first. Pass a returned documentVersionId to fetch with the documentId to read that version and its comments. Omit it and fetch reads the latest draft. |
| `PRODUCTNOW_MCP_MOVE` | Move | Move documents or folders into another folder, including several at once. Pass ids, a mix of document ids and folder ids, plus one parentFolderId. Omit parentFolderId to file everything at the root. Does not change document content — use edit_document for that. Moves every id it can. Ids the user cannot move come back in permissionDeniedIds. A folder moved into itself or into one of its descendants comes back in refusedIds and stays where it is. Ids that are not a document or folder here come back in unresolvedIds. The rest are still moved. |
| `PRODUCTNOW_MCP_REMEMBER` | Remember | Store one piece of information in ProductNow when the user says 'remember this', 'save this', or 'note that…' about their company, product, customers, or team. Pass the fact as `content`; ProductNow decides where it belongs — it searches the warehouse, edits the existing document that covers the topic, or creates a new one in the right folder. ProductNow handles search, folder selection, and document choice within the background job, so separate search, fetch, or placement is not needed. Returns success immediately; a success response means the job was queued and processing continues in the background. Polling is not supported. Use edit_document or create_document instead only when the user already named the exact document or outlined a whole new document. |
| `PRODUCTNOW_MCP_RENAME` | Rename | Change a document or folder's name. Pass one id — a document id or a folder id — and name. Changes the name only. Does not change document content; that is edit_document. One item per call, because each item gets its own name. |
| `PRODUCTNOW_MCP_REPLY_TO_THREAD` | Reply to thread | Reply to an existing comment thread on a document, posted as the user's personal agent. Not an edit — use edit_document to change the document's content. Pass threadId from a document fetch. |
| `PRODUCTNOW_MCP_SEARCH` | Search | Search the company's shared context — its intranet of documents, decisions, meeting notes, and synced systems — and return excerpts relevant to the user's question, with citations. Every source carries the document's id, title, and url; pass the id to fetch for the full text. Use this when the user's request depends on current information about their company, product, customers, team, or enterprise intranet. Covers ProductNow documents (PRDs, specs, RFCs, decisions) plus content synced from whichever sources the workspace has connected, e.g. GitHub, Jira, Linear, Salesforce, ServiceNow, Zendesk, Slack, Teams, Confluence, Notion, Google Drive, and meeting notes. Not for reading a known document in full (fetch) or listing a folder (fetch_folder). To find a folder by name, pass resultType folders. Pass query whenever the user names a topic, including when filters are also present. If the user asks only which documents match creator/date filters and names no topic, omit query to list documents by latest content edit; listing sources contain metadata but no excerpts. creatorNames matches document creators, not editors or contributors; its entries combine with OR, while creator and date filters combine with AND. Search workspace documents by default; use product_help only for questions about how ProductNow works. Pass folderId to limit workspace search to that folder and every folder nested under it; no results come from outside it. Omit folderId to search the whole workspace. Resolve the id with fetch_folder first. Ignored when searchScope is product_help. Pass resultType folders to search folder names instead of documents. Omit resultType to search documents. Folder results are name matches and include each folder's id, name, updatedAt, createdBy, isPrivate, parentFolderId when nested, and folderPath (the parent path) when it has a parent. They have no excerpts. A query is required. creatorNames and date filters apply to documents only. product_help cannot search folders. Topic-search results are relevance-filtered; all result sets are capped. Each source includes the document's folderId and folderPath when it is filed in a folder, and omits both when the document is at the warehouse root. Answer from the excerpts when possible, cite the documents you use, read a source document with `fetch` only when its excerpts are genuinely insufficient, and state uncertainty when evidence is weak or conflicting. |
| `PRODUCTNOW_MCP_UPDATE_DOCUMENT_STATUS` | Update document status | Change a document's lifecycle when the user wants a snapshot, a review, or to publish. Pass documentId and status as an action verb — snapshot, review, or publish — not a version status. snapshot saves a read-only copy of the current draft, review opens that draft for comments, and publish makes it the published version. Each one leaves a fresh draft for later edits. Returns previousStatus and status as version statuses such as DRAFT, SNAPSHOT, REVIEW, or PUBLISHED, the same values list_document_versions filters on. Not move, which files documents and folders into a folder, and not a way to check whether an edit is still running. |
| `PRODUCTNOW_MCP_UPLOAD_MEDIA` | Upload media | Upload a media file (image or video) to ProductNow storage. Returns a signed backend `uploadUrl` valid for 5 minutes for transfer of the user-selected file. Also returns a `url` and `htmlText` you can embed in documents immediately. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to ProductNow MCP
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["productnow_mcp"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["productnow_mcp"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run ProductNow MCP tools with your agent

Send a request, execute the ProductNow MCP tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "Search ProductNow company context for the latest product launch brief and summarize it."}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Search ProductNow company context for the latest product launch brief and summarize it." }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to ProductNow MCP and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["productnow_mcp"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["productnow_mcp"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a ProductNow MCP request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to ProductNow MCP tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("Search ProductNow company context for the latest product launch brief and summarize it.")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Search ProductNow company context for the latest product launch brief and summarize it.",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native ProductNow MCP Integration

- Supports both ProductNow MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for searching company context and managing documents, folders, versions, comments, and media

### 2. Managed Auth

- Supports DCR OAuth authentication for secure ProductNow MCP access
- Central place to manage, scope, and revoke ProductNow MCP access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access ProductNow MCP
- Scoped, least privilege access to ProductNow MCP resources
- Full audit trail of agent actions to support review and compliance

## Use ProductNow MCP with any AI Agent Framework

Choose a framework you want to connect ProductNow MCP with:

- [ChatGPT](https://composio.dev/toolkits/productnow_mcp/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/productnow_mcp/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/productnow_mcp/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/productnow_mcp/framework/atomic-agent)

## Related Toolkits

- [Google Drive](https://composio.dev/toolkits/googledrive) - Google Drive is a cloud storage platform for uploading, sharing, and collaborating on files. It's perfect for keeping your documents accessible and organized across devices.
- [Google Docs](https://composio.dev/toolkits/googledocs) - 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.
- [Google Super](https://composio.dev/toolkits/googlesuper) - Google Super is an all-in-one suite combining Gmail, Drive, Calendar, Sheets, Analytics, and more. It gives you a unified platform to manage your digital life, boosting productivity and organization.
- [ActiveMerge](https://composio.dev/toolkits/active_merge) - ActiveMerge is a document automation platform for generating documents, images, merged files, and e-signature workflows. It helps teams turn templates and stored files into finished, shareable documents faster.
- [Affinda](https://composio.dev/toolkits/affinda) - Affinda is an AI-powered document processing platform that automates data extraction from resumes, invoices, and more. It streamlines document-heavy workflows by turning files into structured, actionable data.
- [Agility cms](https://composio.dev/toolkits/agility_cms) - Agility CMS is a headless content management system for building and managing digital experiences across platforms. It lets teams update content quickly and deliver omnichannel experiences with ease.
- [Airparser](https://composio.dev/toolkits/airparser) - Airparser is an AI-powered parser for extracting structured data from emails, documents, PDFs, and files. It turns messy inbound content into clean fields your apps and workflows can use.
- [Algodocs](https://composio.dev/toolkits/algodocs) - Algodocs is an AI-powered platform that automates data extraction from business documents. It delivers fast, secure, and accurate processing without templates or manual training.
- [Api2pdf](https://composio.dev/toolkits/api2pdf) - Api2Pdf is a REST API for generating PDFs from HTML, URLs, and documents using powerful engines like wkhtmltopdf and Headless Chrome. It streamlines document conversion and automation for developers and businesses.
- [Archive.org](https://composio.dev/toolkits/archive_org) - Archive.org is the Internet Archive's digital library of websites, books, audio, video, and images. Use it to preserve, explore, and access historical web captures and public-domain media.
- [Aryn](https://composio.dev/toolkits/aryn) - Aryn is an AI-powered platform for parsing, extracting, and analyzing data from unstructured documents. Use it to automate document processing and unlock actionable insights from your files.
- [Boldsign](https://composio.dev/toolkits/boldsign) - Boldsign is a digital eSignature platform for sending, signing, and tracking documents online. Organizations use it to automate agreements and manage legally binding workflows efficiently.
- [Boloforms](https://composio.dev/toolkits/boloforms) - BoloForms is an eSignature platform built for small businesses, offering unlimited signatures, templates, and forms. It simplifies digital document signing and team collaboration at a predictable, fixed price.
- [Box](https://composio.dev/toolkits/box) - Box is a cloud content management and file sharing platform for businesses. It helps teams securely store, organize, and collaborate on files from anywhere.
- [Box MCP](https://composio.dev/toolkits/box_mcp) - Box MCP is Box's hosted MCP server that exposes enterprise files, folders, and metadata. It provides secure, centralized access to corporate content for search and management.
- [Carbone](https://composio.dev/toolkits/carbone) - Carbone is a blazing-fast report generator that turns JSON data into PDFs, Word docs, spreadsheets, and more using flexible templates. It lets you automate document creation at scale with minimal code.
- [Castingwords](https://composio.dev/toolkits/castingwords) - CastingWords is a transcription service specializing in human-powered, accurate transcripts via a simple API. Get seamless audio-to-text conversion for interviews, meetings, podcasts, and more.
- [CertSeal](https://composio.dev/toolkits/cert_seal) - CertSeal is an API platform for issuing and managing verifiable digital certificates. Use it to automate trusted certificate workflows for recipients, batches, designs, and webhooks.
- [Cloudconvert](https://composio.dev/toolkits/cloudconvert) - CloudConvert is a powerful file conversion service supporting over 200 file formats. It streamlines converting, compressing, and managing documents, media, and more, all in one place.
- [Cloudlayer](https://composio.dev/toolkits/cloudlayer) - Cloudlayer is a document and asset generation service for creating PDFs and images via API or SDKs. It lets you automate high-quality doc creation, saving dev time and reducing manual work.

## Frequently Asked Questions

### Do I need my own developer credentials to use ProductNow MCP with Composio?

Yes, ProductNow MCP requires you to configure your own Dcr OAuth credentials. Once set up, Composio handles secure credential storage and management for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

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