Clear Ideas + Cursor via MCP

Developers frequently face context-switching challenges. You're deep in code, debugging a complex issue, when leadership requests a quick project update. Typically, this means leaving your IDE, gathering information from multiple sources, and formatting everything for business stakeholders.

Cursor now supports direct integration with Clear Ideas via the Model Context Protocol (MCP), eliminating this workflow friction. You can stay inside Cursor, use AI to pull relevant context from your secure Clear Ideas sites, and save polished reports directly where business teams collaborate.

This creates a bridge between technical work and business communication — transforming how developers contribute to organizational knowledge.

For full details about the Clear Ideas MCP tools, see the Model Context Protocol documentation.

1. Setting Up Clear Ideas in Cursor

Cursor supports remote MCP servers via configuration. Connecting Clear Ideas takes two steps: creating an MCP access key and registering the Clear Ideas MCP endpoint.

Step 1: Create an MCP Access Key in Clear Ideas

In Clear Ideas, go to Settings → Access Keys.
Click New Access Key.
Choose MCP as the key type.
Select scopes:
- mcp:read for read-only use (listing sites, searching content, retrieving context, viewing versions and diffs).
- mcp:write only if you want to create files/folders or save new versions.
(Optional) Set an expiration date.
Copy the key value — you’ll use it in Cursor as a bearer token.

Under the hood, this key is sent to the MCP endpoint via:

Authorization: Bearer YOUR_MCP_ACCESS_KEY

Step 2: Configure Cursor

Configure the Clear Ideas MCP server in Cursor by editing your MCP configuration file:

Project-specific: .cursor/mcp.json in your repo, or
Global: ~/.cursor/mcp.json

Add (or extend) the mcpServers section like this:

{
  "mcpServers": {
    "clearideas": {
      "url": "https://api.clearideas.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_MCP_ACCESS_KEY"
      }
    }
  }
}

Cursor will use this configuration to talk directly to the Clear Ideas MCP endpoint using JSON-RPC over HTTP.

In Cursor, clearideas will appear as an available MCP server. All Clear Ideas MCP tools — clearideas.list_sites, clearideas.list_content, clearideas.search_content, clearideas.retrieve_context, clearideas.retrieve_context_for_file, clearideas.retrieve_diff_for_file, clearideas.save_file, clearideas.create_folder, and more — become available directly from your IDE.

Important: This setup uses your existing AI subscription (Claude Pro, ChatGPT Plus, Cursor's built-in models, etc.) with Clear Ideas as the secure data source. The AI model runs in your MCP host (e.g., Cursor); Clear Ideas provides tools and context, not the AI model itself.

2. A Developer-Centric Workflow Example (Unified Across Hosts)

The following example is shared across our IDE and CLI integrations: querying log data for a new release, summarizing it, saving a report, and later diffing changes over time.

You’ve just shipped a new release. Leadership wants a quick readout on how error rates and performance look post-deployment. You want to stay in Cursor, analyze logs, and deliver a business-ready report into Clear Ideas.

Step 1: Search for Relevant Logs

In the Cursor AI chat panel, you might start with:

Use clearideas.search_content to find error rate or performance logs for the “Release v3.2” site.

Behind the scenes, Cursor will plan a tool call like:

{
  "tool": "clearideas.search_content",
  "params": {
    "q": "error rate OR performance logs",
    "siteIds": ["release-v3.2-site-id"],
    "limit": 20,
    "searchType": "hybrid"
  }
}

You can also take advantage of the expanded parameters described in the MCP docs — for example, scoping by mimeTypes or changing the searchType to full-text or completion when needed.

Step 2: Retrieve Context

Next, ask Cursor:

Retrieve context from the top 10 log files and summarize error rate trends and latency impacts.

Cursor can call:

{
  "tool": "clearideas.retrieve_context",
  "params": {
    "query": "error rate latency trends",
    "siteIds": ["release-v3.2-site-id"],
    "maxChunks": 20,
    "maxTokens": 4000
  }
}

Here, maxChunks and maxTokens map directly to the MCP tool definition — they control how much context comes back and how big the response can be, which is helpful when you’re working with large log sets.

Step 3: AI Analysis

Using the retrieved context, Cursor generates a clean Markdown summary:

# Release v3.2 – Post-Deployment Report

## Error Rates
- Average error rate stabilized at **0.8%** within 48h of rollout.
- Initial spike (~3.2%) linked to legacy API deprecation.

## Performance
- Latency improved by **18%** for critical endpoints.
- 95th percentile latency dropped from 420ms → 345ms.

## Recommendations
1. Monitor deprecation notices more proactively (preventable spike).
2. Scale observability for service X (still near capacity).

You stay in the editor the whole time — prompt, inspect the tool output, refine the analysis, and iterate quickly.

Step 4: Save Back Into Clear Ideas

Finally, tell Cursor:

Save this Markdown as “Release v3.2 – Post-Deployment Report.md” in the “Executive Updates” folder of the same site.

Cursor calls:

{
  "tool": "clearideas.save_file",
  "params": {
    "siteId": "release-v3.2-site-id",
    "folderId": "executive-updates-folder-id",
    "name": "Release v3.2 – Post-Deployment Report.md",
    "content": "# Release v3.2 – Post-Deployment Report\n\n## Error Rates..."
  }
}

Under the hood this uses clearideas.save_file from the MCP docs, creating a new file (or a new version if you pass fileId).

The report is now stored, versioned, and instantly visible to leadership in Clear Ideas.

Step 5: Compare With the Version From a Week Ago

Later, you might want to see what changed in the report over time — for example, all edits made during the last week.

Ask Cursor:

Use clearideas.retrieve_diff_for_file to show all changes between the current version of “Release v3.2 – Post-Deployment Report.md” and the version from one week ago.

Cursor can translate this into a date-based diff call:

{
  "tool": "clearideas.retrieve_diff_for_file",
  "params": {
    "contentId": "release-v3.2-report-content-id",
    "versionAsOf": "2025-11-20T10:00:00Z",
    "priorVersionAsOf": "2025-08-20T10:00:00Z"
  }
}

The tool returns a diff (for example, unified or git-style) so you can quickly see what changed:

@@ -1,8 +1,8 @@
 ## Error Rates
-- Average error rate stabilized at **1.1%** within 48h of rollout.
+- Average error rate stabilized at **0.8%** within 48h of rollout.
 - Initial spike (~3.2%) linked to legacy API deprecation.

 ## Performance
-- Latency improved by **12%** for critical endpoints.
-- 95th percentile latency dropped from 420ms → 370ms.
+- Latency improved by **18%** for critical endpoints.
+- 95th percentile latency dropped from 420ms → 345ms.

This makes it trivial to answer questions like “what changed this week?” or to prepare a narrative for stakeholders that highlights exactly how the story has evolved.

Note: Claude Code and Codex reuse the same Clear Ideas MCP tools in their own hosts. For host‑specific setup, see Parts 3 and 4 of this series.

3. Why This Transforms Collaboration

Cursor closes the gap between development work and business communication. Developers no longer need to jump between tools or repackage findings for leadership; they can stay in their editor, assemble the right evidence, and publish polished updates into Clear Ideas where the rest of the organization already works. Business teams benefit from immediate access to structured summaries that live alongside source material, complete with versioning and proper access controls. Instead of scattering insights across ad-hoc documents, everything lands in a consistent, trustworthy place.

This approach is also different from posting updates to GitHub or other developer-centric systems. Those tools are built for code, not cross-functional communication. By saving directly into Clear Ideas, technical analysis becomes readable and actionable for non-technical stakeholders without extra translation. The result is a smoother loop: engineers communicate impact in real time, and leadership can respond with clarity and confidence — all without interrupting the development flow.

4. Clear Ideas AI Chat: The Optimized Experience

The Cursor connection is ideal for engineers who want to work end-to-end inside the IDE. For most day-to-day analysis, though, Clear Ideas AI Chat remains the fastest path from question to answer. It keeps source documents at your fingertips, links every insight back to the exact page, and lives in the same place teams use for sharing and review. There is no setup to manage and no context to move around — chat, search, document viewing, and AI Workflows all sit together so follow-ups are natural. Use Cursor when you need developer ergonomics; use AI Chat when the priority is collaboration and verification within a Clear Ideas site.

5. Try It Now

If you're a Cursor user, add Clear Ideas to your MCP configuration and test it with your next project. Write code, analyze data, update stakeholders — all from your development environment.