Context Fetch

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    search_query=["project deadlines", "Q2 planning"],
    max_results=10,
    types=["facts", "preferences"],
    mode="fast"
)

print(f"Found {len(context.facts)} facts, {len(context.preferences)} preferences")

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    search_query=["dietary preferences"],
    mode="fast"
)

for fact in context.facts:
    print(f"[{fact.confidence:.0%}] {fact.content}")
    print(f"  Source: {fact.source}")
    print(f"  Extracted: {fact.extracted_at}")

for pref in context.preferences:
    print(f"[{pref.category}] {pref.content} (strength: {pref.strength:.0%})")

for episode in context.episodes:
    print(f"[{episode.significance:.0%}] {episode.summary}")
    print(f"  Occurred: {episode.occurred_at}")
    print(f"  Participants: {', '.join(episode.participants)}")

for emotion in context.emotions:
    print(f"{emotion.emotion_type} (intensity: {emotion.intensity:.0%})")
    print(f"  Triggered by: {emotion.context}")
    print(f"  Detected: {emotion.detected_at}")

for event in context.temporal_events:
    print(f"{event.content} ({event.temporal_category})")
    print(f"  Valid: {event.event_date} → {event.valid_until or 'open-ended'}")

meta = context.metadata
print(f"Correlation ID: {meta.correlation_id}")
print(f"Source: {meta.source}")              # "cache", "cloud", or "anticipation"
print(f"TTL: {meta.ttl_seconds}s")
if meta.compaction_applied is not None:
    print(f"Compaction applied: {meta.compaction_applied.value}")  # e.g. "adaptive"

# `user_id` is required. `conversation_id` is optional: pass it if you want
# the relevance ranking to bias toward memories from that conversation.
user_context = await sdk.user.context.fetch(
    user_id="user_alice",
    customer_id="acme_corp",                                 # required on B2B instances
    search_query=["travel preferences"],
    max_results=20,
    mode="accurate",
)

# Returns facts, preferences, episodes, emotions, temporal_events
# scoped to user_alice.

# `customer_id` is required for customer-scoped retrieval.
customer_context = await sdk.customer.context.fetch(
    customer_id="acme_corp",
    search_query=["engineering team OKRs"],
    max_results=15,
    mode="accurate",
)

client_context = await sdk.client.context.fetch(
    search_query=["product roadmap"],
    max_results=10,
    mode="fast",
)

ctx = await sdk.fetch(
    user_id="+919812345678",              # user identity (e.g. phone, external id)
    context_mode="conversation-summary",
    include_profile=True,
    last_n_conversations=1,
)

# formatted_context now carries "## Caller Profile" and "## Previous Conversations"
prompt_block = ctx.formatted_context

# Or read the typed fields directly:
if ctx.profile:
    print(ctx.profile.overview)
for call in (ctx.conversations or []):
    print(call.summary_status, call.summary)

# Only retrieve facts and preferences
context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    types=["facts", "preferences"],
    mode="fast"
)

# Only retrieve temporal/episode context
context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    types=["episodes", "temporal"],
    mode="accurate"
)

# Explicitly request all types (same as omitting the parameter)
context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    types=["all"],
    mode="fast"
)

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    search_query=["What are the user's dietary restrictions?"]
)

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    search_query=[
        "dietary preferences and restrictions",
        "favorite restaurants and cuisines",
        "food allergies"
    ],
    max_results=15
)

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    max_results=5
)

context = await sdk.conversation.context.fetch(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    mode="fast"
)

# Access raw response for forward compatibility
raw = context.raw
print(raw.keys())

import json
from openai import AsyncOpenAI

openai = AsyncOpenAI()

async def chat_with_memory(conversation_id: str, user_message: str):
    # Fetch relevant context
    context = await sdk.conversation.context.fetch(
        conversation_id=conversation_id,
        search_query=[user_message],
        max_results=10,
        mode="fast",
        precision_level="medium",  # hot path: skip the refinement pass for a faster response
    )

    # Build memory context string
    memory_lines = []

    if context.facts:
        memory_lines.append("## Known Facts")
        for fact in context.facts:
            if fact.confidence >= 0.7:
                memory_lines.append(f"- {fact.content}")

    if context.preferences:
        memory_lines.append("\n## User Preferences")
        for pref in context.preferences:
            memory_lines.append(f"- {pref.content}")

    if context.episodes:
        memory_lines.append("\n## Relevant Past Interactions")
        for episode in context.episodes:
            memory_lines.append(f"- {episode.summary}")

    memory_context = "\n".join(memory_lines) if memory_lines else "No prior context available."

    # Inject into system prompt
    system_prompt = f"""You are a helpful assistant with access to the user's memory.

Use the following context to personalize your responses. Do not mention
that you are reading from a memory system.

{memory_context}"""

    # Call LLM
    response = await openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ]
    )

    assistant_message = response.choices[0].message.content

    # Ingest the new conversation turn for future memory
    await sdk.memories.create(
        document=f"User: {user_message}\nAssistant: {assistant_message}",
        document_type="ai-chat-conversation",
        user_id="user_12345",
        customer_id="acme_corp",
        mode="long-range",
    )

    return assistant_message