Integration Guide

Use a dedicated app host for paid runtime and billing operations

Default host split for production is marketing on contextlattice.io and paid app/API on app.contextlattice.io.

• Marketing/public site: https://contextlattice.io
• Paid app + dashboard + API: https://app.contextlattice.io
• Billing infrastructure: managed on the app host via deployment-specific configuration.
• Wallet/card checkout: unified purchase flow with provider-specific verification handled server-side.
• Apple Pay + Google Pay: available through Stripe checkout when supported by device/browser.
• Admin verification controls: restricted to owner/admin authenticated operations.

Bring stack up first

Use the launch mode you need, then validate core health before integrating any client.

BOOTSTRAP=1 scripts/first_run.sh
ORCH_KEY="$(awk -F= '/^CONTEXTLATTICE_ORCHESTRATOR_API_KEY=/{print substr($0,index($0,"=")+1)}' .env)"

# choose mode if needed
gmake mem-up
# gmake mem-up-lite
# gmake mem-up-full

curl -fsS http://127.0.0.1:8075/health | jq
curl -fsS -H "x-api-key: ${ORCH_KEY}" http://127.0.0.1:8075/status | jq

• Orchestrator API: http://127.0.0.1:8075
• MCP hub memory endpoint: http://127.0.0.1:53130/memorymcp/mcp
• MCP hub qdrant endpoint: optional in full/operator stacks at http://127.0.0.1:53130/qdrant/mcp

5-minute integration smoke test

Run this once to confirm your app can write and retrieve memory through Context Lattice before wiring UI-specific settings.

ORCH_KEY="$(awk -F= '/^CONTEXTLATTICE_ORCHESTRATOR_API_KEY=/{print substr($0,index($0,"=")+1)}' .env)"

curl -fsS -H "content-type: application/json" -H "x-api-key: ${ORCH_KEY}" \
  -d '{"projectName":"_global","fileName":"smoke/integration_check.md","content":"integration smoke ok"}' \
  http://127.0.0.1:8075/memory/write | jq

curl -fsS -H "content-type: application/json" -H "x-api-key: ${ORCH_KEY}" \
  -d '{"query":"integration smoke ok","limit":3}' \
  http://127.0.0.1:8075/memory/search | jq

• If both calls return ok: true: your app can safely integrate.
• If you get 401: verify CONTEXTLATTICE_ORCHESTRATOR_API_KEY and restart the caller process.

Paste this instruction block into your agent chat

Use this as your first message when starting a new ChatGPT/Claude/Codex/Claude Code session so the agent reliably uses Context Lattice.

You must use Context Lattice as the memory/context layer.

Runtime:
- Orchestrator: http://127.0.0.1:8075
- The CLI reads local runtime configuration; do not print secrets.

Required behavior:
1) Before planning, run contextlattice context "<task>" --project <project> --pretty.
2) Continue work with contextlattice resume --project <project> --pretty; never replay raw transcripts.
3) Save durable progress with contextlattice remember "<checkpoint>" --project <project> --pretty.
4) Report retrieval quality with contextlattice correct "<note>" --category useful|wrong|stale|superseded.
5) Finish with contextlattice finish "<verified result>" --success|--repair|--failure.
6) Run contextlattice doctor --pretty when readiness is unclear.
7) Use HTTP only when the CLI is unavailable or you are implementing a harness/app integration.

• Best practice: include projectName, fileName, and topic path on every write.
• Timeout guidance: fast reads 25s, balanced reads 60s, deep/slow-source reads 75s.
• Cache behavior: first deep read may be slow; retrying the same query often returns faster after staged fetch + cache warm.
• Quality loop: ask user for a short “context quality” rating after key outputs, then write that feedback.
• Goal: resolve an agentic issue once and persist reusable context for the team/organization.

Deep integration for Codex, Claude Code, OpenCode, Hermes, OMP, Mercury, ChatGPT, Claude

The CLI resolves the detected profile, stable agent_id, task session, topic scope, and query defaults without making users assemble lifecycle calls.

# prescribed profile-aware workflow
contextlattice doctor --pretty
contextlattice context "release readiness" --project contextlattice --pretty
contextlattice resume --project contextlattice --pretty
contextlattice remember "checkpoint saved" --project contextlattice --pretty
contextlattice finish "release verified" --success --project contextlattice --pretty

# adoption and capability discovery
contextlattice_adopt status --pretty
contextlattice_adopt integrate --repo . --agents codex,claude-code,opencode,hermes-agent,hermes-ultra,omp,mercury-agent,pi,droid --check --pretty
contextlattice_skills_index search "browser automation" --pretty
contextlattice_agent_adapter profiles

• Profiles supported: codex, claude-code, opencode, hermes-agent, hermes-ultra, omp, mercury-agent, pi, droid, chatgpt-web, chatgpt-desktop, claude-web, claude-desktop.
• Context compiler: contextlattice context turns current objective state, ranked evidence, missing sources, risks, files, and next action into a bounded agent_packet.v1.
• Skills Index: contextlattice_skills_index searches active configured skill roots such as $CODEX_HOME/skills without loading every skill body.
• Template path: docs/public_overview/templates/agents/ (copy-ready prompts and setup blocks).
• Endpoint remains pinned: http://127.0.0.1:8075.

HTTP/messaging app interfacing (claw-ready)

Context Lattice now supports channel command intake via orchestrator-native endpoints. The default handle is @ContextLattice.

POST /integrations/messaging/command
POST /integrations/messaging/openclaw
POST /integrations/messaging/ironclaw
POST /integrations/telegram/webhook
POST /integrations/slack/events

@ContextLattice remember deployment complete
@ContextLattice recall deployment
@ContextLattice status

# local direct test (secure default requires x-api-key)
curl -fsS -H "content-type: application/json" -H "x-api-key: ${ORCH_KEY}" \
  -d '{"channel":"openclaw","source_id":"chat-1","text":"@ContextLattice status"}' \
  http://127.0.0.1:8075/integrations/messaging/command | jq

• BYO accounts: Telegram/Slack credentials stay in your own account.
• Project routing: commands can include project=<name> and topic=<path> directives.
• Default behavior: OpenClaw/ZeroClaw route directly; IronClaw is optional and feature-flagged.

Map OpenClaw/ZeroClaw/IronClaw memory traits directly to Context Lattice endpoints. Keep orchestrator as the single memory control plane.