Backend architecture

SELECT role, content, created_at FROM (
  SELECT role, content, created_at FROM conversation_turns
  WHERE session_id = $1
    AND created_at > now() - interval '2 hours'
  ORDER BY created_at DESC
  LIMIT 12
) recent
ORDER BY created_at ASC;

# recent_turns is stage 4's output, oldest first
messages = [{"role": t["role"], "content": t["content"]} for t in recent_turns]
messages.append({"role": "user", "content": message_text})

system_prompt = f"""{BANDHU_PERSONA_AND_CONSTRAINTS}

Rolling context on this person — for your own awareness only, never to be
recited back to them:
{summary_text or "No prior context yet."}

{_directive_instruction(directive, retrieved_chunks)}
# e.g. "Offer this, once, warmly, only if it fits naturally: <chunk text>"
"""

response_text = await generate(
    model=GENERATE_MODEL,      # small tier — vector-database.md §1
    system=system_prompt,
    messages=messages,
    max_tokens=150,
)

response.set_cookie(
    key="bandhu_sid",
    value=str(session_id),
    max_age=60 * 60 * 24 * 14,   # 14 days — matches the cleanup job's window exactly
    httponly=True,                 # JS on the page can't read or tamper with it
    secure=True,                   # only sent over HTTPS
    samesite="lax",                # normal navigation still sends it; blocks most
                                    # cross-site abuse without breaking anything
)

from slowapi import Limiter
from slowapi.util import get_remote_address

def rate_limit_key(request):
    return request.cookies.get("bandhu_sid") or get_remote_address(request)

limiter = Limiter(key_func=rate_limit_key)

@app.post("/message")
@limiter.limit("20/10minutes")
async def message(...): ...

def cleanup_expired_sessions(db):
    db.execute(
        "DELETE FROM user_sessions WHERE last_active_at < now() - interval '14 days'"
    )
    db.commit()

import base64
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from openinference.instrumentation.openai import OpenAIInstrumentor

auth = base64.b64encode(
    f"{settings.langfuse_public_key}:{settings.langfuse_secret_key}".encode()
).decode()

tracer_provider = TracerProvider()
tracer_provider.add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(
        endpoint="https://cloud.langfuse.com/api/public/otel/v1/traces",
        headers={"Authorization": f"Basic {auth}"},
    ))
)
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

from opentelemetry import trace
tracer = trace.get_tracer("bandhu.pipeline")

def transcribe(audio_bytes):
    with tracer.start_as_current_span("stt") as span:
        result = stt_client.transcribe(audio_bytes)
        span.set_attribute("stt.detected_language", result.language)
        span.set_attribute("stt.duration_seconds", result.duration)
        return result

def retrieve(query_embedding, filters):
    with tracer.start_as_current_span("retrieval") as span:
        results = vector_search(query_embedding, filters)
        span.set_attribute("retrieval.result_count", len(results))
        span.set_attribute("retrieval.entry_keys", [r.entry_key for r in results])
        span.set_attribute("retrieval.top_similarity", results[0].similarity if results else 0)
        return results