GPT models with persistent memory

from openai import AsyncOpenAI
import httpx
import os
from typing import Optional

# Initialize OpenAI client
openai_client = AsyncOpenAI()

# Stompy context helpers
STOMPY_URL = "https://mcp.stompy.ai/sse"
STOMPY_HEADERS = {"Authorization": f"Bearer {os.environ['STOMPY_TOKEN']}"}

async def fetch_stompy_context(topic: str) -> str:
    """Retrieve specific context by topic."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            STOMPY_URL,
            headers=STOMPY_HEADERS,
            json={"tool": "recall_context", "topic": topic}
        )
        return response.json().get("content", "")

async def search_stompy_context(query: str, limit: int = 3) -> list[str]:
    """Semantic search for relevant context."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            STOMPY_URL,
            headers=STOMPY_HEADERS,
            json={"tool": "context_search", "query": query, "limit": limit}
        )
        contexts = response.json().get("contexts", [])
        return [c["content"] for c in contexts]

async def smart_gpt_call(
    user_message: str,
    conversation_history: list[dict] = None,
    model: str = "gpt-4o"
) -> str:
    """Chat completion with persistent project context."""

    # Fetch context in parallel
    import asyncio
    project_rules, tech_context, relevant_context = await asyncio.gather(
        fetch_stompy_context("project_rules"),
        fetch_stompy_context("tech_stack"),
        search_stompy_context(user_message, limit=3)
    )

    # Build enriched system prompt
    system_content = f"""You are an AI assistant with access to project context.

PROJECT RULES:
{project_rules or 'No specific rules defined.'}

TECHNICAL CONTEXT:
{tech_context or 'No technical context available.'}

RELEVANT PREVIOUS CONTEXT:
{chr(10).join(relevant_context) if relevant_context else 'No relevant previous context.'}

Use this context to provide responses consistent with established patterns."""

    # Build messages array
    messages = [{"role": "system", "content": system_content}]
    if conversation_history:
        messages.extend(conversation_history)
    messages.append({"role": "user", "content": user_message})

    # Make the OpenAI call
    response = await openai_client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.7
    )

    return response.choices[0].message.content

async def save_gpt_insight(
    topic: str,
    content: str,
    tags: str = "openai,decisions"
):
    """Persist insights from GPT conversations."""
    async with httpx.AsyncClient() as client:
        await client.post(
            STOMPY_URL,
            headers=STOMPY_HEADERS,
            json={
                "tool": "lock_context",
                "topic": topic,
                "content": content,
                "tags": tags
            }
        )

# Example usage: After GPT helps decide on database approach
await save_gpt_insight(
    topic="database_architecture",
    content="""Database Decision (with GPT-4o analysis):

Choice: PostgreSQL with pgvector for RAG
Rationale:
- Team has Postgres expertise
- pgvector avoids separate vector DB
- ACID compliance important for our use case
- Cost-effective for our scale

Alternatives considered:
- Pinecone (rejected: additional cost and complexity)
- MongoDB Atlas (rejected: weaker transaction support)""",
    tags="database,architecture,decisions"
)