Claude with memory that matches its intelligence

import anthropic
import httpx
import os
from typing import Optional

# Initialize Anthropic client
claude = anthropic.Anthropic()

# Stompy helper functions
async def get_context(topic: str) -> str:
    """Retrieve specific context by topic."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://mcp.stompy.ai/sse",
            headers={"Authorization": f"Bearer {os.environ['STOMPY_TOKEN']}"},
            json={"tool": "recall_context", "topic": topic}
        )
        return response.json().get("content", "")

async def search_relevant_context(query: str, limit: int = 5) -> list[str]:
    """Semantic search for relevant project context."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://mcp.stompy.ai/sse",
            headers={"Authorization": f"Bearer {os.environ['STOMPY_TOKEN']}"},
            json={"tool": "context_search", "query": query, "limit": limit}
        )
        contexts = response.json().get("contexts", [])
        return [c["content"] for c in contexts]

async def smart_claude_call(
    user_message: str,
    conversation_history: list[dict] = None,
    include_search: bool = True
) -> str:
    """Call Claude with persistent project context."""

    # Build context from Stompy
    context_parts = []

    # Always include critical project rules
    rules = await get_context("project_rules")
    if rules:
        context_parts.append(f"PROJECT RULES (always follow):\n{rules}")

    # Include tech stack and architecture
    tech_stack = await get_context("tech_stack")
    if tech_stack:
        context_parts.append(f"TECH STACK:\n{tech_stack}")

    # Semantic search for relevant context
    if include_search:
        relevant = await search_relevant_context(user_message)
        if relevant:
            context_parts.append(f"RELEVANT CONTEXT:\n{chr(10).join(relevant)}")

    # Build system prompt with all context
    system_prompt = """You are a helpful AI assistant with access to project context.
Use the provided context to give responses that are consistent with established
decisions and patterns. If you're unsure about something, say so.

""" + "\n\n".join(context_parts)

    # Make the Claude API call
    response = claude.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=system_prompt,
        messages=conversation_history or [] + [
            {"role": "user", "content": user_message}
        ]
    )

    return response.content[0].text

async def save_claude_insight(
    topic: str,
    content: str,
    priority: str = "important",
    tags: str = ""
):
    """Save insights from Claude sessions to Stompy."""
    async with httpx.AsyncClient() as client:
        await client.post(
            "https://mcp.stompy.ai/sse",
            headers={"Authorization": f"Bearer {os.environ['STOMPY_TOKEN']}"},
            json={
                "tool": "lock_context",
                "topic": topic,
                "content": content,
                "priority": priority,
                "tags": tags or "claude,decisions"
            }
        )

# Example: After Claude helps with architecture
await save_claude_insight(
    topic="api_design_patterns",
    content="""API Design Decision:
- Use REST for CRUD operations
- Use WebSockets for real-time features
- GraphQL considered but rejected (team familiarity)
- All endpoints return consistent error format

Decided with Claude's help during architecture planning session.""",
    priority="always_check",
    tags="architecture,api,decisions"
)