reDB LogoTraceMem

IDE MCP Integration

Learn how to integrate your developer IDE with TraceMem over MCP (Model Context Protocol) to automatically capture and store architecture decisions while working on complex developments.

Overview

TraceMem's Agent MCP server allows you to connect your IDE directly to TraceMem, enabling you to:

  • Capture architecture decisions as you make them during development
  • Store decision context with full traceability and audit trails
  • Document design choices with structured metadata
  • Maintain decision history across your development sessions
  • Enable AI assistants in your IDE to make informed decisions based on past architecture choices

This integration is particularly valuable when working on complex systems where architectural decisions need to be tracked, reviewed, and referenced over time.

Prerequisites

Before setting up the integration, ensure you have:

  1. A TraceMem account - Sign up at app.tracemem.com
  2. An Agent API key - Generate one from your project settings
  3. MCP support - Your IDE must support MCP (Model Context Protocol)

Supported IDEs

This guide covers integration with the following IDEs:

Understanding MCP Configuration

TraceMem's Agent MCP server uses the following configuration:

  • Endpoint: https://mcp.tracemem.com
  • Protocol: JSON-RPC 2.0 over HTTP
  • Authentication: Authorization: Agent <your-api-key> header
  • Content-Type: application/json

IDE-Specific Setup

Claude Code

Claude Code supports MCP servers through its configuration file. For teams building agent services using Anthropic's Messages API with the MCP connector, see the Claude Code Integration guide for direct remote MCP integration.

Basic Configuration

For local Claude Code installations, you can configure MCP servers through the configuration file:

Step 1: Locate Configuration File

The MCP configuration is typically located at:

  • macOS/Linux: ~/.config/claude-code/mcp.json or ~/.claude-code/mcp.json
  • Windows: %APPDATA%\claude-code\mcp.json

Step 2: Add TraceMem MCP Server

Add the TraceMem MCP server configuration:

json
{
  "mcpServers": {
    "tracemem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-fetch"
      ],
      "env": {
        "MCP_SERVER_URL": "https://mcp.tracemem.com",
        "MCP_AUTH_HEADER": "Agent YOUR_API_KEY_HERE"
      }
    }
  }
}

Note: Replace YOUR_API_KEY_HERE with your actual TraceMem Agent API key.

Step 3: Restart Claude Code

Restart Claude Code to load the new MCP server configuration.

Step 4: Verify Connection

In Claude Code, you should now see TraceMem tools available. You can test the connection by asking Claude to list available TraceMem capabilities.

For MCP Connector Integration: If you're using Anthropic's Messages API with the MCP connector for direct remote MCP integration, see the Claude Code Integration guide for complete setup instructions including SKILL.md configuration.

Cursor

Cursor supports MCP servers through its settings.

Step 1: Open Cursor Settings

  1. Open Cursor
  2. Go to Settings (or press Cmd+, on macOS / Ctrl+, on Windows/Linux)
  3. Navigate to Features → MCP (or search for "MCP")

Step 2: Add MCP Server

Add a new MCP server configuration:

json
{
  "mcpServers": {
    "tracemem": {
      "url": "https://mcp.tracemem.com",
      "auth": {
        "type": "header",
        "header": "Authorization",
        "value": "Agent YOUR_API_KEY_HERE"
      }
    }
  }
}

Note: Replace YOUR_API_KEY_HERE with your actual TraceMem Agent API key.

Step 3: Restart Cursor

Restart Cursor to apply the configuration.

Step 4: Test Integration

You can test the integration by using Cursor's AI assistant to create a decision envelope. The TraceMem tools should be available in the AI context.

Antigravity

Antigravity supports MCP through its configuration system.

Step 1: Open Antigravity Settings

  1. Open Antigravity
  2. Navigate to Settings → MCP Servers

Step 2: Configure TraceMem Server

Add the following configuration:

yaml
mcp_servers:
  tracemem:
    endpoint: https://mcp.tracemem.com
    auth:
      type: bearer
      token: YOUR_API_KEY_HERE
    protocol: jsonrpc2

Note: Replace YOUR_API_KEY_HERE with your actual TraceMem Agent API key.

Step 3: Restart Antigravity

Restart Antigravity to load the new configuration.

Visual Studio Code

VS Code requires an MCP extension to connect to MCP servers.

Step 1: Install MCP Extension

  1. Open VS Code
  2. Go to Extensions (or press Cmd+Shift+X / Ctrl+Shift+X)
  3. Search for "MCP" or "Model Context Protocol"
  4. Install a compatible MCP extension (e.g., "MCP Client" or similar)

Step 2: Configure MCP Server

Add configuration to your VS Code settings (.vscode/settings.json or user settings):

json
{
  "mcp.servers": {
    "tracemem": {
      "command": "node",
      "args": [
        "-e",
        "require('@modelcontextprotocol/sdk').createClient({url: 'https://mcp.tracemem.com', auth: {type: 'header', header: 'Authorization', value: 'Agent YOUR_API_KEY_HERE'}})"
      ]
    }
  }
}

Alternative: If using an MCP extension with a different configuration format, follow the extension's documentation and use:

  • URL: https://mcp.tracemem.com
  • Auth Header: Authorization: Agent YOUR_API_KEY_HERE

Step 3: Reload VS Code

Reload VS Code window (Cmd+R / Ctrl+R) or restart VS Code.

Using TraceMem in Your IDE

Once configured, you can use TraceMem tools directly from your IDE's AI assistant. Here are common use cases:

Capturing Architecture Decisions

When making an architectural decision, you can ask your IDE's AI assistant to:

text
Create a decision envelope for the architecture decision to use microservices 
for the new payment system. Intent: "architecture.payment.microservices.design"

The AI will use the decision_create tool to create a decision envelope, which you can then use to track all related operations.

Documenting Design Choices

As you implement features, you can add context to your decisions:

text
Add context to decision TMEM_abc123: "Chose PostgreSQL over MongoDB for 
transactional consistency requirements in the payment processing module."

Storing Decision Traces

After completing a feature or making a significant architectural change:

text
Close decision TMEM_abc123 with status "commit" and summary of the 
microservices architecture implementation.

Example Workflow

Here's a typical workflow when working on a complex feature:

  1. Start Development

    • Ask your IDE AI: "Create a decision envelope for implementing the new authentication system"
    • This creates a decision envelope with intent like "architecture.auth.system.design"

  2. Make Design Choices

    • As you make decisions, add context: "Add context: Chose OAuth2 over SAML for better mobile support"
    • The AI uses decision_add_context to record your reasoning

  3. Track Implementation

    • Document key implementation details: "Add context: Implemented JWT token refresh with 15-minute expiry"

  4. Complete and Close

    • When done: "Close the decision envelope with commit status"
    • This finalizes the decision trace with all context and creates an immutable audit record

Security Best Practices

  1. Protect Your API Key

    • Never commit API keys to version control
    • Use environment variables or IDE-specific secure storage when possible
    • Rotate keys regularly

  2. Use Environment Variables

    • Store your API key in an environment variable:
      bash
      export TRACEMEM_API_KEY="your-api-key-here"
    • Reference it in your MCP configuration:
      json
      "value": "Agent ${TRACEMEM_API_KEY}"

  3. Review Decision Access

    • Ensure only authorized team members have access to your TraceMem project
    • Review decision traces regularly for compliance

Troubleshooting

Connection Issues

If you're unable to connect to TraceMem:

  1. Verify API Key: Ensure your API key is correct and active
  2. Check Network: Verify you can reach https://mcp.tracemem.com
  3. Review Logs: Check your IDE's console/logs for error messages
  4. Test Endpoint: Try accessing the endpoint directly with curl:
    bash
    curl -H "Authorization: Agent YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}' \
     https://mcp.tracemem.com

Tools Not Available

If TraceMem tools don't appear in your IDE:

  1. Restart IDE: Fully restart your IDE after configuration changes
  2. Check Configuration: Verify the MCP configuration syntax is correct
  3. Extension Issues: For VS Code, ensure the MCP extension is properly installed and enabled
  4. Permissions: Ensure your API key has the necessary permissions

Authentication Errors

If you receive authentication errors:

  1. Verify Header Format: Ensure the Authorization header is exactly Agent <api-key> (with a space)
  2. Check Key Validity: Verify your API key hasn't expired or been revoked
  3. Review Project Settings: Ensure the key belongs to the correct TraceMem project

Related Topics

Next Steps

reDB LogoTraceMem

TraceMem is trace-native infrastructure for AI agents

reDBBlog