Infinite Context (ICX) Developer Portal

# pip install calera-agent-memory
from calera_agent_memory import CaleraClient

# 1. Initialize client and create an isolated memory space
client = CaleraClient(api_key="clabs_live_your_api_key")
space = client.spaces.create("research_core", description="Enterprise knowledge lattice")

# 2. Store structured facts or execution state into 4D topological lattice
client.lattice.store(
    concept="NVDA_FY26_Rev",
    association="Estimated at $168B on Blackwell datacenter expansion",
    space_id="research_core"
)

# 3. Sub-5ms topological lattice recall with boundary refusal (∂² = 0)
results = client.lattice.recall(
    query="NVDA revenue projection",
    space_id="research_core",
    max_depth=2
)
print("Lattice Recall:", results)

// npm install @calera/icx
import { CaleraClient } from '@calera/icx';

const client = new CaleraClient({ apiKey: process.env.ICX_API_KEY });

// 1. Create or bind to an isolated memory space
const space = await client.spaces.create({
  name: 'production_core',
  description: 'Core microservice topology'
});

// 2. Ingest structured facts into 4D topological memory lattice
await client.lattice.store({
  spaceId: space.id,
  concept: 'NVDA_FY26_Rev',
  association: 'Estimated at $168B on Blackwell datacenter expansion'
});

// 3. Sub-5ms topological lattice recall with ∂² = 0 boundary refusal
const memory = await client.lattice.recall({
  spaceId: space.id,
  query: 'NVDA revenue projection',
  maxDepth: 2
});
console.log('Lattice recall:', memory);

# pip install calera-agent-memory langchain
from calera_agent_memory import CaleraMemorySubstrate

# Auto-provisions a free 1M-node persistent memory vault under Delaware UETA § 14
memory = CaleraMemorySubstrate(principal_email="developer@company.com")

# Drop directly into LangChain, CrewAI, or AutoGen agent loops
memory.save_context({"input": "Q3 Target Launch"}, {"output": "November 14, 2026"})
context = memory.load_memory_variables({"input": "When is the launch?"})
print(context["history"])

import os
from openai import OpenAI

# Connect standard OpenAI client to ICX API gateway (Zero custom packages required)
client = OpenAI(
    api_key=os.environ.get("ICX_API_KEY", "clabs_live_your_api_key"),
    base_url="https://icx.api.caleralabs.com/v1",
    default_headers={
        "X-Space-ID": "enterprise_core"
    }
)

# Query persistent memory — ICX handles associative memory recall automatically
response = client.chat.completions.create(
    model="calera-vln-icx",
    messages=[
        {"role": "user", "content": "Summarize key risk factors in Section 1A from our ingested filings."}
    ]
)

print(response.choices[0].message.content)

// .cursor/mcp.json — same object as https://icx.caleralabs.com/install.json
{
  "mcpServers": {
    "icx": {
      "url": "https://icx.caleralabs.com/mcp",
      "serverUrl": "https://icx.caleralabs.com/mcp",
      "headers": {
        "X-License-Key": "clabs_live_YOUR_KEY"
      }
    }
  }
}

# Ingest text into persistent memory
curl -X POST https://icx.api.caleralabs.com/v1/ingest/text \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "knowledge_base",
    "text": "Project Apollo Launch Date: November 14, 2026. Target Orbit: 420km LEO. Lead Architect: Dr. Vance.",
    "source_id": "apollo_spec_v1"
  }'

# Query via standard chat completions
curl -X POST https://icx.api.caleralabs.com/v1/chat/completions \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "X-Space-ID: knowledge_base" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "When is Project Apollo scheduled to launch?"}]
  }'

curl -X POST https://icx.api.caleralabs.com/v1/chat/completions \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "X-Space-ID: production_kb" \
  -H "X-LLM-Provider: anthropic" \
  -H "X-LLM-API-Key: sk-ant-your-upstream-key" \
  -H "X-LLM-Model: claude-3-5-sonnet-20241022" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "messages": [
      {"role": "system", "content": "You are a helpful engineering assistant."},
      {"role": "user", "content": "Explain our authentication architecture from the security whitepaper."}
    ],
    "stream": true,
    "temperature": 0.2
  }'

{
  "id": "chatcmpl-icx-8f81a3d0",
  "object": "chat.completion",
  "created": 1756141200,
  "model": "claude-3-5-sonnet-20241022",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "According to Section 3 of the security whitepaper, the authentication architecture uses..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 820,
    "completion_tokens": 145,
    "total_tokens": 965
  },
  "calera": {
    "product": "ICX",
    "kind": "epistemic_coprocessor",
    "answer_source": "upstream_llm",
    "prompt_authority": "connected_agent",
    "speaker": "connected_agent",
    "requested_model": "claude-3-5-sonnet-20241022",
    "remediation": "ICX is the epistemic co-processor and supplied the memory viewport. The upstream model named by X-LLM-Model wrote message.content. A system persona steers only that upstream model."
  },
  "vln_telemetry": {
    "space_id": "production_kb",
    "facts_recalled": 18,
    "crystallization_nodes": 452000,
    "recall_latency_ms": 1.48,
    "token_savings_pct": 99.82
  }
}

curl -X POST https://icx.api.caleralabs.com/v1/ingest/file \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -F "file=@./legal_contract_2026.pdf" \
  -F "space_id=legal_contracts" \
  -F "source_id=contract_acme_2026"

{
  "status": "success",
  "space_id": "legal_contracts",
  "source_id": "contract_acme_2026",
  "filename": "legal_contract_2026.pdf",
  "bytes_processed": 482910,
  "nodes_crystallized": 1420,
  "edges_formed": 4830,
  "crystallization_time_ms": 32.4
}

curl -X POST https://icx.api.caleralabs.com/v1/ingest/text \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "crm_knowledge",
    "source_id": "ticket_98214",
    "text": "Customer AcmeCorp requested custom SSO domain routing on cluster us-central1-c. Lead Contact: Sarah Chen.",
    "metadata": {
      "customer": "AcmeCorp",
      "priority": "P1",
      "timestamp": "2026-08-25T14:30:00Z"
    }
  }'

curl -X POST https://icx.api.caleralabs.com/v1/ingest/bulk \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "entire_codebase",
    "documents": [
      {"source_id": "file_1.ts", "text": "export const CONFIG = {...};"},
      {"source_id": "file_2.ts", "text": "export function initDatabase() {...};"}
    ]
  }'

curl -X POST https://icx.api.caleralabs.com/v1/sync/connectors \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "github",
    "space_id": "backend_repo",
    "target": "calera-computing/core-engine",
    "branch": "main",
    "auto_sync": true
  }'

curl -X POST https://icx.api.caleralabs.com/v1/sync/webhook/generic \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "ci_builds",
    "source_id": "build_20260825_981",
    "event_type": "deploy_success",
    "payload": "Deployed revision rev-981 to cluster-prod-east. All 42 health checks passed."
  }'

curl -X POST https://icx.api.caleralabs.com/v1/sync/connectors \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "mcp",
    "space_id": "tool_warehouse",
    "target": "https://remote-mcp.example.com/sse",
    "auto_sync": true
  }'

curl -X POST https://icx.api.caleralabs.com/v1/sync/purge \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "space_id": "legal_contracts",
    "source_id": "contract_acme_2026"
  }'

{
  "status": "purged",
  "space_id": "legal_contracts",
  "source_id": "contract_acme_2026",
  "nodes_unlinked": 1420,
  "purge_latency_ms": 1.12
}

curl -X GET https://icx.api.caleralabs.com/v1/memory/spaces \
  -H "Authorization: Bearer clabs_live_your_api_key"

{
  "spaces": [
    {
      "space_id": "backend_repo",
      "nodes_count": 842000,
      "sources_count": 142,
      "last_sync": "2026-08-25T16:20:00Z"
    },
    {
      "space_id": "legal_contracts",
      "nodes_count": 215000,
      "sources_count": 38,
      "last_sync": "2026-08-24T18:10:00Z"
    }
  ]
}

# Python SDK: client.spaces.create(...)
space = client.spaces.create("backend_repo", description="Core monorepo AST lattice")
spaces_list = client.spaces.list()

# TypeScript SDK: client.spaces.create(...)
const space = await client.spaces.create({
  name: 'backend_repo',
  description: 'Core monorepo AST lattice'
});
const spaces = await client.spaces.list();

curl -X POST https://icx.api.caleralabs.com/api/session/reset \
  -H "Authorization: Bearer clabs_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "sess_user_482"
  }'

# pip install calera-agent-memory
from calera_agent_memory import CaleraClient, CaleraMemorySubstrate

# 1. Initialize client and create an isolated memory space
client = CaleraClient(api_key="clabs_live_your_api_key")
space = client.spaces.create("finance_core", description="GAAP 10-K models")

# 2. Store facts directly into 4D topological lattice (sub-5ms O(1) recall)
client.lattice.store(
    concept="FY26_EBITDA_Target",
    association="Projected at $4.2B with 38% operating margin",
    space_id="finance_core"
)
recalled = client.lattice.recall("EBITDA margin target", space_id="finance_core", max_depth=2)
print("Topological Recall:", recalled)

# 3. Multi-hop simplicial lattice walk across associative manifolds
walk_res = client.lattice.walk(start_node="FY26_EBITDA_Target", target_node="operating_margin")
print("Lattice Walk:", walk_res)

# 4. LangChain / CrewAI callers. ICX remains the epistemic co-processor.
memory = CaleraMemorySubstrate(principal_email="developer@company.com")
memory.save_context({"input": "What is our Q4 quota?"}, {"output": "$12.5M ARR"})
history = memory.load_memory_variables({"input": "Q4 quota"})
print("Substrate History:", history)

import os
import requests
from openai import OpenAI

API_KEY = os.environ.get("ICX_API_KEY", "clabs_live_your_api_key")
BASE_URL = "https://icx.api.caleralabs.com/v1"
SPACE_ID = "engineering"

# 1. Ingest local files or documentation into persistent memory
with open("architecture_spec.md", "rb") as f:
    resp = requests.post(
        f"{BASE_URL}/ingest/file",
        headers={"Authorization": f"Bearer {API_KEY}", "X-Space-ID": SPACE_ID},
        files={"file": f}
    )
    print("Ingested file:", resp.json())

# 2. Query persistent memory with streaming using standard OpenAI SDK
client = OpenAI(
    api_key=API_KEY,
    base_url=BASE_URL,
    default_headers={"X-Space-ID": SPACE_ID}
)

stream = client.chat.completions.create(
    model="calera-vln-icx",
    messages=[{"role": "user", "content": "How does our caching layer handle cache misses?"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

# 1. Authenticate CLI
export ICX_API_KEY="clabs_live_your_api_key"

# 2. Watch a local folder and sync file changes in real-time
icx watch ./src --space codebase_main

# 3. One-shot push of a documentation folder
icx push ./docs --space knowledge_base

# 4. View current tenant sync status and memory node count
icx status --space codebase_main

# 5. Instantly purge a deleted module from memory
icx purge deprecated_module_v1 --space codebase_main

{
  "mcpServers": {
    "icx": {
      "url": "https://icx.caleralabs.com/mcp",
      "serverUrl": "https://icx.caleralabs.com/mcp",
      "headers": {
        "X-License-Key": "clabs_live_YOUR_KEY"
      }
    }
  }
}

claude mcp add --transport http icx https://icx.caleralabs.com/mcp --header "X-License-Key: clabs_live_YOUR_KEY"

import { CaleraClient } from '@calera/icx';

const client = new CaleraClient({
  apiKey: process.env.ICX_API_KEY
});

async function main() {
  // 1. Create or bind to an isolated memory space
  const space = await client.spaces.create({
    name: 'production_app',
    description: 'Production runbooks and incident procedures'
  });

  // 2. Ingest domain facts into the 4D topological memory lattice
  await client.lattice.store({
    spaceId: space.id,
    concept: 'Tier1_SLA_Ceiling',
    association: 'Tier-1 incident response time ceiling is strictly 15 minutes.'
  });

  // 3. Sub-5ms topological lattice recall with ∂² = 0 boundary refusal
  const memory = await client.lattice.recall({
    spaceId: space.id,
    query: 'What are the SLA response times for Tier-1 incidents?',
    maxDepth: 2
  });

  console.log('Topological Recall:', memory);
}

main();

import OpenAI from 'openai';

const icx = new OpenAI({
  apiKey: process.env.ICX_API_KEY,
  baseURL: 'https://icx.api.caleralabs.com/v1',
  defaultHeaders: {
    'X-Space-ID': 'production_app'
  }
});

async function main() {
  const completion = await icx.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'user', content: 'What are the SLA response times for Tier-1 incidents?' }
    ]
  });

  console.log(completion.choices[0].message.content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	payload, _ := json.Marshal(map[string]any{
		"model": "gpt-4o",
		"messages": []map[string]string{
			{"role": "user", "content": "Summarize project requirements."},
		},
	})

	req, _ := http.NewRequest("POST", "https://icx.api.caleralabs.com/v1/chat/completions", bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("ICX_API_KEY"))
	req.Header.Set("X-Space-ID", "core_specs")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

curl -X GET "https://icx.api.caleralabs.com/v1/lattice/search?space_id=engineering&q=database+sharding&limit=5" \
  -H "Authorization: Bearer clabs_live_your_api_key"

{
  "query": "database sharding",
  "space_id": "engineering",
  "total_matches": 3,
  "facts": [
    {
      "fact_id": "f_8921a",
      "text": "User database is sharded across 16 PostgreSQL partitions based on tenant UUID hash.",
      "source_id": "db_architecture_v2.md",
      "relevance_score": 0.96
    }
  ]
}

curl -X POST https://icx.api.caleralabs.com/v1/lattice/geodesic \
  -H "Authorization: Bearer $CALERA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "premise": "AAPL_REV",
    "target": "FREE_CASH_FLOW",
    "max_steps": 10
  }'

{
  "status": "success",
  "premise": "AAPL_REV",
  "target": "FREE_CASH_FLOW",
  "steps": 5,
  "action_cost": 5.66,
  "ribbon": "[nav:ribbon premise=\"AAPL_REV\" target=\"FREE_CASH_FLOW\" steps=5 action=5.66]\nAAPL_REV -> OPERATING_INCOME -> TAX_EXPENSE -> NOPAT -> FREE_CASH_FLOW",
  "milestones": [
    { "index": 0, "concept_id": "AAPL_REV", "action_cost": 0.0, "curvature": 0.0 },
    { "index": 1, "concept_id": "OPERATING_INCOME", "action_cost": 1.41, "curvature": 0.12 },
    { "index": 2, "concept_id": "TAX_EXPENSE", "action_cost": 2.83, "curvature": -0.05 },
    { "index": 3, "concept_id": "NOPAT", "action_cost": 4.24, "curvature": 0.08 },
    { "index": 4, "concept_id": "FREE_CASH_FLOW", "action_cost": 5.66, "curvature": 0.0 }
  ],
  "duration_ms": 0.82,
  "stationary_action": true,
  "notice": "Substrate topology is not included in API responses."
}

from openai import OpenAI

client = OpenAI(
    base_url="https://icx.api.caleralabs.com/v1",
    api_key="clabs_live_...",
    default_headers={"X-ICX-Geodesic-Ribbon": "true"}
)

response = client.chat.completions.create(
    model="calera-vln-icx",
    messages=[
        {"role": "user", "content": "How does Q4 revenue flow into Free Cash Flow?"}
    ],
    extra_body={"enable_geodesic_ribbon": True}
)

# Access geodesic telemetry inside OpenAI response
telemetry = response.vln_telemetry
if telemetry and hasattr(telemetry, "geodesic_ribbon"):
    print("Geodesic Ribbon Chain:\n", telemetry.geodesic_ribbon)
    print("Ribbon Tokens:", telemetry.ribbon_tokens)
    print("TTFT Reduction:", f"{telemetry.ttft_reduction_pct}%")

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://icx.api.caleralabs.com/v1",
  apiKey: process.env.CALERA_API_KEY,
  defaultHeaders: { "X-ICX-Geodesic-Ribbon": "true" }
});

const completion = await client.chat.completions.create({
  model: "calera-vln-icx",
  messages: [{ role: "user", content: "Trace AAPL_REV to FREE_CASH_FLOW." }]
});

console.log("answer_source:", completion.calera.answer_source);
console.log("content:", completion.choices[0].message.content);

{
  "name": "recall_epistemic_context",
  "arguments": {
    "query": "AAPL_REV",
    "format": "ribbon"
  }
}