One call. Every framework. Same memory.

import { StateGraph } from "@langchain/langgraph";
import { LoreClient } from "@loregpt/sdk";

const lore = new LoreClient({ apiKey });

// a node writes what it learned — nothing blocks
async function researcher(state) {
  const { seq } = await lore.write({
    runId: state.runId, agentId: "researcher",
    content: "Auth flow moved to v2 — PR #42 merged",
  });
  return { ...state, seq };
}

// a later node reads a pack that is guaranteed to contain it
async function writer(state) {
  const pack = await lore.pack({
    query: "current state of auth work",
    scopes: { team: "platform" },
    minSeq: state.seq,          // read-your-writes
    tokenBudget: 2000,
  });
  // pack.coveredSeq >= state.seq  → the write is in there, guaranteed
  return { ...state, context: pack.text };
}

from crewai import Agent, Crew
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)

# each agent writes events to shared memory
seq = lore.write(
    run_id=run_id, agent_id="researcher",
    content="Auth flow moved to v2 — PR #42 merged",
).seq

# the next agent reads a consistent, budget-fit pack
pack = lore.pack(
    query="current state of auth work",
    scopes={"team": "platform"},
    min_seq=seq,            # read-your-writes
    token_budget=2000,
)
# pack.covered_seq >= seq  → guaranteed to include the write

// Register the Lore MCP server with your client (e.g. Claude Code)
{
  "mcpServers": {
    "lore": {
      "command": "lore",
      "args": ["mcp", "--scope", "team:platform"]
    }
  }
}

// The client now has tools:
//   lore.write(agentId, content)      -> { seq }
//   lore.pack(query, minSeq, budget)  -> { text, coveredSeq, savedTokens }
// read-your-writes and access control are enforced server-side.

import { query } from "@anthropic-ai/claude-agent-sdk";

// Point the agent at Lore's MCP server — shared memory as tools.
const run = query({
  prompt: "Summarize where the auth work stands, then keep building it.",
  options: {
    mcpServers: {
      lore: { type: "stdio", command: "lore", args: ["mcp", "--scope", "team:platform"] },
    },
    // read-your-writes + access control are enforced server-side
    allowedTools: ["mcp__lore__write", "mcp__lore__pack"],
  },
});

for await (const msg of run) {
  if (msg.type === "assistant") console.log(msg.message.content);
}

from agents import Agent, Runner, function_tool
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)

@function_tool
def remember(content: str) -> int:
    """Write an event to shared memory; returns its sequence number."""
    return lore.write(run_id=RUN_ID, agent_id="researcher", content=content).seq

@function_tool
def recall(query: str, min_seq: int) -> str:
    """Read a budget-fit, read-your-writes context pack."""
    return lore.pack(run_id=RUN_ID, query=query, min_seq=min_seq, token_budget=2000).text

writer = Agent(
    name="Writer",
    instructions="Coordinate through shared memory — recall before you write.",
    tools=[remember, recall],
)

result = Runner.run_sync(writer, "Continue the auth work the researcher started.")
print(result.final_output)

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.anthropic import AnthropicChatCompletionClient
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)

def remember(content: str) -> str:
    """Write an event to shared memory."""
    seq = lore.write(run_id=RUN_ID, agent_id="coder", content=content).seq
    return f"stored seq {seq}"

def recall(query: str) -> str:
    """Read a consistent, budget-fit context pack."""
    return lore.pack(run_id=RUN_ID, query=query, token_budget=2000).text

coder = AssistantAgent(
    name="coder",
    model_client=AnthropicChatCompletionClient(model="claude-opus-4-8"),
    tools=[remember, recall],
    system_message="Share what you learn through Lore; recall before you act.",
)

from pydantic_ai import Agent
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)
agent = Agent("anthropic:claude-opus-4-8", system_prompt="Recall before you write.")

@agent.tool_plain
def remember(content: str) -> int:
    """Write an event to shared memory; returns its sequence number."""
    return lore.write(run_id=RUN_ID, agent_id="researcher", content=content).seq

@agent.tool_plain
def recall(query: str) -> str:
    """Read a budget-fit, read-your-writes context pack."""
    return lore.pack(run_id=RUN_ID, query=query, token_budget=2000).text

result = agent.run_sync("Continue the auth work the researcher started.")
print(result.output)

from google.adk.agents import Agent
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)

def remember(content: str) -> dict:
    """Write an event to shared memory."""
    return {"seq": lore.write(run_id=RUN_ID, agent_id="researcher", content=content).seq}

def recall(query: str) -> dict:
    """Read a consistent, budget-fit context pack."""
    return {"pack": lore.pack(run_id=RUN_ID, query=query, token_budget=2000).text}

writer = Agent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="Coordinate through shared memory — recall before you write.",
    tools=[remember, recall],
)

from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function
from loregpt import LoreClient

lore = LoreClient(api_key=API_KEY)

class LoreMemory:
    @kernel_function(description="Write an event to shared memory.")
    def remember(self, content: str) -> str:
        return f"stored seq {lore.write(run_id=RUN_ID, agent_id='coder', content=content).seq}"

    @kernel_function(description="Read a consistent, budget-fit context pack.")
    def recall(self, query: str) -> str:
        return lore.pack(run_id=RUN_ID, query=query, token_budget=2000).text

kernel = Kernel()
kernel.add_plugin(LoreMemory(), plugin_name="lore")