Documentation

// app/api/chat/route.ts
import { streamText, convertToCoreMessages } from 'ai'
import { mnemo } from '@forge/sdk'

export async function POST(req: Request) {
  const { messages, tools } = await req.json()

  // 1. Compress prior turns (lossless) before sending to the LLM.
  const compressed = await forge.memory.compress(messages)

  // 2. Let Mnemo's on-device orchestrator decide tool calls.
  const decision = await forge.orchestrator.execute({
    messages: compressed,
    tools,
  })

  // 3. Stream a final answer using your existing provider.
  const result = await streamText({
    model: yourProvider, // openai('gpt-4o'), anthropic('claude-3-5-sonnet'), etc.
    messages: convertToCoreMessages(compressed),
    tools,
  })

  return result.toDataStreamResponse()
}

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from forge import ForgeOrchestrator, ForgeMemory

llm = ForgeOrchestrator(model="nano-q4")    # on-device JSON-only
memory = ForgeMemory()                       # lossless 4-code compression

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("placeholder", "{chat_history}"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

await executor.ainvoke({"input": "What's 23 * 17?"})

from langgraph.graph import StateGraph, END
from forge import ForgeMemory, ForgeOrchestrator

memory = ForgeMemory()
orch  = ForgeOrchestrator(model="nano-q4")

def call_model(state):
    state["messages"] = memory.compress(state["messages"])
    decision = orch.execute(state["messages"], state["tools"])
    if decision.tool_calls:
        state["pending_calls"] = decision.tool_calls
    else:
        state["final"] = decision.content
    return state

graph = StateGraph(dict)
graph.add_node("model", call_model)
graph.set_entry_point("model")
graph.add_edge("model", END)
app = graph.compile()

from forge import Forge

forge = Forge(api_key=os.environ['FORGE_KEY'])

# Memorizer
codes = forge.memorizer.compress(text='User prefers dark mode.').codes
text = forge.memorizer.decompress(codes=codes).text
assert text == 'User prefers dark mode.'

# Orchestrator
result = forge.orchestrator.execute(
    messages=[{'role': 'user', 'content': 'Calculate 5 + 2'}],
    tools=[{
        'type': 'function',
        'function': {
            'name': 'calc',
            'description': 'Evaluate a math expression',
            'parameters': {
                'type': 'object',
                'properties': {'expr': {'type': 'string'}},
                'required': ['expr'],
            },
        },
    }],
)

if result.tool_calls:
    for call in result.tool_calls:
        print(call.function.name, call.function.arguments)

// Load Mnemo Orchestrator in the browser
import * as ort from 'onnxruntime-web'

const session = await ort.InferenceSession.create('/models/orchestrator_int8.onnx')

export async function runOnDevice(messages, tools) {
  const inputIds = tokenize(buildPrompt(messages, tools))
  const feeds = { input_ids: new ort.Tensor('int32', inputIds, [1, inputIds.length]) }
  const out = await session.run(feeds)
  return parseJsonTokens(out.logits)
}

// React Native / Expo
import * as tf from '@tensorflow/tfjs'
import '@tensorflow/tfjs-react-native'

const model = await tf.loadGraphModel(
  'https://cdn.forge.ai/models/memorizer_int8.tflite'
)

export function compressOnDevice(text) {
  const ids = tokenize(text)
  const out = model.predict(tf.tensor2d([ids])) as tf.Tensor
  return Array.from(out.dataSync()).slice(0, 4) // 4 codes
}

// llama.cpp server
./server -m orchestrator_q4.gguf --port 8080 --json-schema \
  '{"type":"object","properties":{"content":{"type":["string","null"]},"tool_calls":{"type":["array","null"]}}}' \
  --max-tokens 200

# Client (any OpenAI-compatible client)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"orchestrator","messages":[...]}'