Claude Code Integration

{
  "mcp_servers": {
    "tracemem": {
      "url": "https://mcp.tracemem.com",
      "command": null
    }
  }
}

import anthropic
import json

# Initialize the Anthropic client
client = anthropic.Anthropic(
    api_key="your-anthropic-api-key"
)

# Configure MCP connector with TraceMem
mcp_config = {
    "mcp_servers": {
        "tracemem": {
            "url": "https://mcp.tracemem.com",
            "command": None
        }
    }
}

# Make a request with MCP connector enabled
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system="You are a helpful assistant with access to TraceMem for decision tracking.",
    messages=[
        {
            "role": "user",
            "content": "Create a decision envelope for refactoring the user authentication system."
        }
    ],
    # Enable MCP connector with beta header
    extra_headers={
        "anthropic-beta": "mcp-connector-2024-10-22"
    },
    # Configure MCP servers
    tools=mcp_config.get("mcp_servers", {}),
    # Authentication for TraceMem MCP server
    tool_choice="auto"
)

headers = {
    "anthropic-beta": "mcp-connector-2024-10-22",  # Beta feature header
    "x-api-key": "your-anthropic-api-key",
    # TraceMem authentication is handled via MCP server configuration
}

# The MCP connector will automatically include:
# Authorization: Agent <your-traceme-api-key>
# 
# Configure this when setting up the MCP server connection

# TraceMem Decision Tracking Skill

## Overview

This skill enables Claude Code to track architecture decisions, code changes, and design choices using TraceMem's decision envelope system.

## When to Use TraceMem

Always create a decision envelope when:
- Making architectural decisions
- Refactoring code
- Implementing new features
- Making database schema changes
- Deploying changes
- Modifying configuration
- Changing security settings

## TraceMem Lifecycle

### 1. Create Decision Envelope

Before starting work, create a decision envelope:

    Use the decision_create tool with:
    - intent: A structured intent like "code.refactor.execute" or "architecture.auth.system.design"
    - automation_mode: "propose" (for review) or "auto" (for automatic approval)
    - metadata: Relevant context about the decision

### 2. Add Context Throughout Work

As you make progress, add context to the decision:

    Use decision_add_context to document:
    - Design choices and rationale
    - Implementation details
    - Trade-offs considered
    - Dependencies identified

### 3. Evaluate Policies (if applicable)

If your decision involves data access or policy evaluation:

    Use decision_evaluate to check:
    - Policy compliance
    - Data access permissions
    - Approval requirements

### 4. Request Approval (if needed)

If policy evaluation returns "requires_exception":

    Use decision_request_approval to:
    - Request human approval
    - Provide clear context for approvers
    - Wait for approval before proceeding

### 5. Read/Write Data (if needed)

If your decision involves data access:

    Use decision_read to:
    - Query data products
    - Understand current state
    - Gather context for decisions

    Use decision_write to:
    - Make data changes
    - Update records
    - Create new entries

### 6. Close Decision

When work is complete, close the decision:

    Use decision_close with:
    - outcome: "commit" (success), "abort" (cancelled), or "reject" (rejected)
    - summary: Brief summary of what was accomplished

## Intent Naming Conventions

Use structured intents following this pattern:

- `code.change.apply` - Code changes
- `code.refactor.execute` - Code refactoring
- `architecture.<domain>.<component>.<action>` - Architecture decisions
- `deploy.release.execute` - Deployments
- `data.change.apply` - Database changes
- `secrets.change.propose` - Secret modifications

## Example Workflow

1. **Start**: "I'm going to refactor the authentication system"
   - Create decision with intent: "code.refactor.execute"
   
2. **Progress**: "I'm extracting the auth logic into a separate service"
   - Add context: "Extracting authentication logic to improve testability"
   
3. **Complete**: "Refactoring complete, all tests passing"
   - Close decision with outcome: "commit"

## Important Notes

- Always create a decision envelope before starting significant work
- Add context throughout the work, not just at the end
- Use appropriate intents to categorize decisions
- Close decisions explicitly - don't leave them open
- If approval is required, wait for it before proceeding
- Use decision_read to understand current state before making changes

"Before starting this refactoring, review SKILL.md for TraceMem decision tracking guidelines."

import anthropic
import json
import os

# Configuration
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
TRACEMEM_API_KEY = os.getenv("TRACEMEM_API_KEY")

client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)

# MCP configuration with TraceMem
mcp_servers = {
    "tracemem": {
        "url": "https://mcp.tracemem.com",
        "command": None,
        # Authentication is configured via MCP connector
        # The connector will use: Authorization: Agent <TRACEMEM_API_KEY>
    }
}

# Example: Ask Claude to create a decision and refactor code
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    system="""
    You are a helpful coding assistant with access to TraceMem for decision tracking.
    
    When making significant changes:
    1. Create a decision envelope using decision_create
    2. Add context as you work using decision_add_context
    3. Close the decision when complete using decision_close
    
    Review SKILL.md for detailed TraceMem lifecycle guidelines.
    """,
    messages=[
        {
            "role": "user",
            "content": """
            I want to refactor the user authentication system to use OAuth2.
            Please:
            1. Create a TraceMem decision envelope
            2. Document the approach
            3. Implement the refactoring
            4. Close the decision when done
            """
        }
    ],
    extra_headers={
        "anthropic-beta": "mcp-connector-2024-10-22"
    },
    tools=mcp_servers,
    tool_choice="auto"
)

# Process the response
print(response.content)