Context Engineering, Done Right: A Pragmatic Playbook with Recallio (and real API calls)

Recallio Team

— 6 min read
Context Engineering, Done Right: A Pragmatic Playbook with Recallio (and real API calls)

If your “AI assistant” still forgets decisions from last week’s meeting, repeats intake questions, or recommends actions that contradict current policy, the issue isn’t the model - it’s context. Models are powerful pattern machines, but they’re amnesic and literal. Unless you systematically feed them the right information at the right time, they will guess.

Below is a field guide that (1) spells out the real pain in larger organizations with many data inputs and (2) shows exactly how to implement context engineering using Recallio’s API. No hand-waving. Copy-pasteable calls included.

The Enterprise Pain (why “prompting harder” won’t fix it)

  1. Stateless brains
    LLMs don’t remember. Every turn starts from zero unless you reconstruct what matters.
  2. Fragmented truth
    Your reality lives in chatbots, CRM, ticketing, analytics, email, wikis, PDFs, calendar events, call transcripts, meeting notes, code repos, and IoT/telemetry. Most agents see a thin slice and hallucinate the rest.
  3. Temporal drift
    Facts evolve: a feature was deprecated yesterday; a customer’s plan changed this morning; a safety bulletin went out an hour ago. If your system doesn’t encode when facts were true, the model will grab stale context.
  4. Latency & token bloat
    Naïve “fetch everything” pipelines create slow, expensive prompts. P95 spikes; users bounce.
  5. Scope bleed
    Multi-tenant and project-based work demands hard scoping. Mixing users/projects/teams in retrieval contaminates answers.
  6. Multi-agent incoherence
    Parallel agents without shared, canonical context produce mismatched parts and force a human to glue them together.
  7. Compliance & control gaps
    You need verifiable consent on write, clean export on request, and guaranteed deletion. If you can’t prove that, risk teams will (rightly) block production.
  8. No observability
    When an answer goes wrong, you can’t show which memories or relationships the system used. You’re guessing at fixes.

What Context Engineering Is (and isn’t)

Definition: The disciplined design of capture → indexing → retrieval → compression → assembly → governance so each LLM/tool call receives the minimum, sufficient, current information to finish the task—traced and controllable.

Principles that hold up in production

  • Small, sharp memories: Store concise facts, decisions, preferences, and doc snippets—tagged and scoped.
  • Temporal awareness: Retain timestamps and supersession (what changed, when).
  • Selective retrieval: Pull only what’s relevant, with thresholds and tags.
  • Compression first: Summarize and dedupe before you hit the model.
  • Deterministic assembly: Emit a single, labeled context block per task.
  • Governable state: Consent on write; export and delete on demand.

Real Scenarios in a Large Organization

A) B2B SaaS (Sales, Success, Support, Product, Finance)

Inputs: chatbot threads, CRM account tier & renewal date, support tickets, release notes (PDFs), weekly success-sync notes, product telemetry, billing flags.
Outcome: When a user asks “Why do our nightly exports fail again?”, the agent assembles: latest telemetry error signature, the runbook snippet, last meeting’s deadline, and plan limits—then proposes a fix that respects the customer’s tier and the migration path agreed in the sync.

B) Airline (Loyalty, Operations, Care)

Inputs: booking system, seat maps, disruption alerts, loyalty history, chat/email interactions, call transcripts.
Outcome: “Rebook me tonight.” The agent knows status level, same-carrier preference from past choices, current disruption waiver, and a travel companion note from last month’s call—so it proposes two realistic rebook options and auto-applies the waiver.

C) Healthcare Access (Non-diagnostic navigation)

Inputs: portal messages, appointment history, benefits eligibility, care-team notes, reminders, PDF pre-op instructions.
Outcome: “What do I need before Friday’s procedure?” The agent returns the correct, current prep steps, acknowledges last week’s pre-op call, and attaches the updated hospital PDF with a clean summary.

D) Manufacturing / Field Service

Inputs: IoT sensor anomalies, prior service logs, inventory, safety advisories, technician chat, dispatch records.
Outcome: Before a site visit, the agent provides a one-page brief: last failure mode, replaced parts, the safety bulletin from yesterday, and the gate code from the prior ticket.

E) Enterprise IT Service Desk

Inputs: Slack/Teams threads, ticketing, device management alerts, change calendar, onboarding docs.
Outcome: “Schedule my usual check-in.” The agent infers cadence, attendees, and last agenda from calendar/ticket context and proposes the next slot with the same doc links.

Part 2 — Implement It with Recallio (copy-paste code)

Core loop: Write → Recall/Graph → Assemble → Use → Govern

Set your base and token:

export RECALLIO_BASE="https://app.recallio.ai"
export RECALLIO_TOKEN="YOUR_BEARER_TOKEN"

A) Store a user preference from chatbot

import requests

requests.post(
    f"{RECALLIO_BASE}/api/Memory/write",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "userId": "user_123",
        "projectId": "proj_ops",
        "content": "Prefers weekly summaries on Mondays at 9am; dark mode enabled.",
        "tags": ["preferences", "ui", "cadence"],
        "metadata": {"source": "chatbot", "timestamp": "2025-08-12T14:30:00Z"},
        "consentFlag": True
    }
)

B) Save distilled meeting notes

requests.post(
    f"{RECALLIO_BASE}/api/Memory/write",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "userId": "acct_acme",
        "projectId": "proj_ops",
        "content": "Nightly export failing on large attachments; mitigation: switch to incremental export by the 15th; owner: Priya.",
        "tags": ["meeting", "export", "mitigation"],
        "metadata": {"source": "success_sync", "timestamp": "2025-08-11T16:00:00Z"},
        "consentFlag": True
    }
)

2) Knowledge Graph: encode relationships and evolution

Add relationships when “who/what/when/why” matters (ownership, migration reasons, supersession).

requests.post(
    f"{RECALLIO_BASE}/api/GraphMemory/add",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "data": "Aug 2025: ACME migrated to incremental export due to attachment limits. Owner: Priya.",
        "user_id": "acct_acme",
        "project_id": "proj_ops"
    }
)

3) Retrieval: pull the smallest useful set

A) Precision recall (ranked facts; tune similarity to reduce noise)

requests.post(
    f"{RECALLIO_BASE}/api/Memory/recall?limit=8&similarityThreshold=0.4",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "userId": "acct_acme",
        "projectId": "proj_ops",
        "query": "export failures and current mitigation plan",
        "scope": "project",
        "tags": ["export", "mitigation", "docs", "meeting"]
    }
)

B) Token-friendly summary across many items

requests.post(
    f"{RECALLIO_BASE}/api/Memory/recall-summary",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "userId": "acct_acme",
        "projectId": "proj_ops",
        "scope": "project",
        "tags": ["export"]
    }
)

C) Graph search (edges explain why/ownership/timeline)

requests.post(
    f"{RECALLIO_BASE}/api/GraphMemory/search",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "query": "current export approach, reason for change, accountable owner",
        "user_id": "acct_acme",
        "project_id": "proj_ops",
        "limit": 10,
        "threshold": 0.35
    }
)

D) Relationship snapshot (audit/debug/guardrails)

requests.get(
    f"{RECALLIO_BASE}/api/GraphMemory/relationships",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}"},
    params={
        "userId": "acct_acme",
        "projectId": "proj_ops",
        "limit": 200
    }
)

4) Assemble one deterministic context block (the thing you actually send)

TypeScript helper: blends summarized context + top graph edges + a few high-confidence facts into one block.

import fetch from "node-fetch";

const BASE = process.env.RECALLIO_BASE!;
const TOKEN = process.env.RECALLIO_TOKEN!;
const H = { "Authorization": `Bearer ${TOKEN}`, "Content-Type": "application/json" };

export async function buildContextBlock(
  userId: string,
  projectId: string,
  task: string,
  tags: string[] = []
) {
  const summary = await fetch(`${BASE}/api/Memory/recall-summary`, {
    method: "POST", headers: H,
    body: JSON.stringify({ userId, projectId, scope: "project", tags })
  }).then(r => r.json());

  const graph = await fetch(`${BASE}/api/GraphMemory/search`, {
    method: "POST", headers: H,
    body: JSON.stringify({ query: task, user_id: userId, project_id: projectId, limit: 8, threshold: 0.35 })
  }).then(r => r.json());

  const facts = await fetch(`${BASE}/api/Memory/recall?limit=6&similarityThreshold=0.5`, {
    method: "POST", headers: H,
    body: JSON.stringify({ userId, projectId, query: task, scope: "project", tags })
  }).then(r => r.json());

  const graphLines = (graph || [])
    .map((g: any) => `- ${g.source} --[${g.relationship}]--> ${g.destination} (score=${(g.score ?? 0).toFixed(2)})`)
    .join("\n");

  const factLines = (facts || [])
    .map((f: any) => `- ${f.content} (score=${(f.similarityScore ?? 0).toFixed(2)})`)
    .join("\n");

  return [
    `# CONTEXT_SUMMARY\n${summary?.content ?? ""}`.trim(),
    `# GRAPH_FACTS\n${graphLines}`.trim(),
    `# FACTS\n${factLines}`.trim(),
    `# TASK\n${task}`.trim()
  ].join("\n\n");
}

Using it with your LLM call:

const task = "Explain current export failures for ACME and propose next steps within plan limits.";
const context = await buildContextBlock("acct_acme", "proj_ops", task, ["export","mitigation"]);

const prompt = `You are a reliability assistant.
${context}

# REQUIREMENTS
- Be specific and reference recent actions and owners.
- Provide a 3-step plan that respects account limits and timelines.
- If critical info is missing, ask exactly one clarifying question.`;

const completion = await llm.generate({ prompt }); // your LLM/tool of choice

5) Govern: export and delete (prove you’re in control)

A) Export memories (JSON or CSV)

requests.get(
    f"{RECALLIO_BASE}/api/Memory/export",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}"},
    params={
        "Type": "fact",
        "Format": "json",
        "UserId": "acct_acme",
        "ProjectId": "proj_ops"
    }
)

B) Delete by scope (manager keys only)

requests.delete(
    f"{RECALLIO_BASE}/api/Memory/delete",
    headers={"Authorization": f"Bearer {RECALLIO_TOKEN}", "Content-Type": "application/json"},
    json={
        "scope": "project",
        "projectId": "proj_ops"
    }
)

Operational Playbook (do this from day one)

  • Thresholds: start at similarityThreshold=0.35; raise toward 0.6–0.7 in noisy corpora.
  • Tags: use them aggressively ("export", "billing", "meeting", "docs") to narrow retrieval.
  • Summaries first: prefer /Memory/recall-summary for latency & token efficiency; add 3–6 raw facts for verifiability.
  • Graph selectively: reach for /GraphMemory/* when you need ownership, causality, or timeline clarity.
  • Observability: log the final assembled block with a request ID; keep a “why” trace for incident reviews.
  • Scopes: never mix users/projects/teams in the same retrieval call unless you mean to.

Bottom line

Context engineering isn’t clever prompting; it’s data and ops. With Recallio you can wire the end-to-end loop—capture → recall/graph → assemble → use → govern—using a handful of HTTP calls and one deterministic context block per task. That’s how you stop agents from guessing and start delivering answers you can defend.

Read more