MCP (JSON-RPC 2.0) + Python SDK + CLI

Developer API

Build intelligent developer tools with AI-powered code understanding. Knowledge graphs, pattern detection, semantic search, and session continuity.

40+
API Endpoints
17k+
CS Patterns
6
Languages
<100ms
Avg Latency

Core API Capabilities

Everything you need to build intelligent code understanding into your tools

Knowledge Graphs

Create persistent knowledge graphs from your codebase. Classes, functions, relationships, and patterns - all queryable via API.

POST /mcp/createWorldModel

Code Analysis

Analyze code for patterns, anti-patterns, complexity, and quality. Get actionable insights with educational explanations.

POST /mcp/analyze_code

Pattern Detection

Detect design patterns, algorithms, and anti-patterns using our trained ML models. 17,600+ CS knowledge entities.

POST /mcp/detect_patterns

Session Continuity

AI sessions that remember context across conversations. Create handoffs, restore state, maintain project understanding.

POST /mcp/createSessionHandoff

Semantic Search

Search captured knowledge by meaning, not just keywords. Find decisions, patterns, and context using natural language.

POST /mcp/searchProjectKnowledge

Proactive Insights

AI that thinks about your codebase even when you're not asking. Get architecture suggestions and issue detection.

GET /mcp/getProactiveInsights

Automatic Synthesis

AI-powered summarization of your work into comprehensive AINOTES. Decisions, architecture, priorities - all synthesized.

POST /mcp/synthesizeProjectContext

API, SDK, and CLI access requires Pro tier or above. Start with Starter to explore the web interface with a limited trial of these features.

Quick Start Examples

Get started in minutes with our Python SDK, CLI, or direct API calls

Command Line Interface

Pro+

Available for Linux, macOS, and Windows. Analyze code, manage projects, and integrate with your workflow.

pip install createstate
# Restore yesterday's AI session - picks up exactly where you left off
$ create-state handoff restore c82b5806-d0ef-4b6b
[OK] Session Restored | Active Model: my-project | Pending Insights: 3

# Analyze code and capture to your knowledge graph
$ create-state analyze ./src --capture

# Ask questions about your codebase using captured knowledge
$ create-state search "authentication flow"
Python SDKRecommended - Pro tier and above
# Install: pip install createstate
from createstate import CreateStateClient

client = CreateStateClient(api_key="your_api_key")

# Create a knowledge graph for your project
model = client.create_world_model(
    project_name="my-project",
    language="python"
)

# Analyze code for patterns
analysis = client.analyze_code(
    code="""
    def fibonacci(n):
        if n <= 1: return n
        return fibonacci(n-1) + fibonacci(n-2)
    """,
    include_suggestions=True
)

# Result includes detected patterns, complexity,
# and suggestions for improvement
print(analysis.patterns)  # ['recursion', 'divide_and_conquer']
print(analysis.suggestions[0].title)
# "Consider memoization for exponential recursion"
REST APIAny language - Pro tier and above
# Analyze code via REST API
curl -X POST https://<your-mcp-server>/mcp \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "analyze_code",
      "arguments": {
        "code": "def hello(): print(\"world\")",
        "language": "python",
        "include_suggestions": true
      }
    },
    "id": 1
  }'

# Response
{
  "result": {
    "quality_score": 0.85,
    "patterns_detected": [...],
    "suggestions": [...],
    "educational_insights": [...]
  }
}
Integrates with your favorite tools
Cursor
Claude
OpenAI
VS Code
GitHub CopilotCopilot
LovableLovable
Google AntigravityAntigravity
Model Context Protocol Pro+

Native MCP Integration

First-class support for Anthropic's Model Context Protocol via JSON-RPC 2.0. Connect Create State directly to Claude, Cursor, or any MCP-compatible client. Available on Pro tier and above.

  • Cursor IDE - Add to your MCP config for AI-powered code understanding
  • Claude Code - Seamless integration with Claude's coding capabilities
  • Custom Clients - Build your own MCP tools using our endpoints
View Full Documentation

Complete API documentation available after signing up

Session restore in Cursor IDE - AI context preserved across sessions

Session restore in Cursor - AI picks up exactly where you left off

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "create-state-mcp": {
      "url": "https://<your-mcp-server>/mcp/",
      "headers": {
        "Authorization": "Bearer <your_api_key>",
        "Content-Type": "application/json"
      }
    }
  }
}

Supported Languages

Python
JavaScript
TypeScript
Java
Go
Rust

More languages coming soon. Request support at support@createstate.ai

Authentication

All authenticated endpoints require a Bearer token in the Authorization header.

Authorization: Bearer <your_api_key>

API keys available on Pro tier and above. Generate keys in your dashboard after signing up.

Rate Limits

  • Starter (Free) 100 req/day
  • Pro 10,000 req/day
  • Power 100,000 req/day
  • Enterprise Unlimited
View full pricing details

Ready to Build Intelligent Developer Tools?

Get started with our free tier. No credit card required.