Infinite Context (ICX) WebMCP — In-Browser Epistemic Memory Protocol

import os
import httpx
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

@tool
def icx_query_memory(query: str, max_depth: int = 2) -> dict:
    """Queries Infinite Context (ICX) persistent memory for grounded architectural facts."""
    response = httpx.post(
        "https://icx.api.caleralabs.com/v1/memory/query",
        headers={
            "X-License-Key": os.environ["ICX_LICENSE_KEY"],
            "Content-Type": "application/json",
        },
        json={"query": query, "max_depth": max_depth},
    )
    return response.json()

tools = [icx_query_memory]
llm = ChatOpenAI(model="gpt-4o", temperature=0.0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an autonomous coding assistant with persistent ICX memory."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

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

result = executor.invoke({"input": "Recall the ICX memory conservation delay invariants from our vault."})
print(result["output"])

import os
from crewai import Agent, Task, Crew
from crewai.tools import tool
import httpx

@tool("ICX Persistent Memory Recall")
def icx_recall(query: str) -> str:
    """Recalls grounded facts and codebase invariants from Infinite Context persistent memory."""
    res = httpx.post(
        "https://icx.api.caleralabs.com/v1/memory/query",
        headers={"X-License-Key": os.environ["ICX_LICENSE_KEY"], "Content-Type": "application/json"},
        json={"query": query}
    )
    if res.status_code == 200:
        return f"ICX Grounded Facts: {res.json()}"
    return "Memory recall failed or no nodes match the query."

memory_architect = Agent(
    role="Principal System Knowledge Architect",
    goal="Maintain zero-loss institutional memory across sprint cycles.",
    backstory="You rely exclusively on Infinite Context (ICX) persistent memory to preserve structural invariants.",
    tools=[icx_recall],
    verbose=True
)

audit_task = Task(
    description="Recall the microservice communication specs and verify against the current task backlog.",
    expected_output="A structured memory synthesis report with SHA-256 node proofs.",
    agent=memory_architect
)

crew = Crew(agents=[memory_architect], tasks=[audit_task])
crew.kickoff()

import os
from autogen import AssistantAgent, UserProxyAgent, register_function
import httpx

def icx_store_fact(concept: str, association: str) -> dict:
    """Stores a newly discovered codebase fact or invariant into persistent memory."""
    return httpx.post(
        "https://icx.api.caleralabs.com/v1/memory/store",
        headers={"X-License-Key": os.environ["ICX_LICENSE_KEY"], "Content-Type": "application/json"},
        json={"concept": concept, "association": association}
    ).json()

analyst = AssistantAgent(
    name="Memory_Coordinator",
    llm_config={"config_list": [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}]},
    system_message="Store all synthesized invariants into ICX persistent memory using icx_store_fact."
)

user_proxy = UserProxyAgent(
    name="User_Proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=2,
    code_execution_config=False
)

register_function(
    icx_store_fact,
    caller=analyst,
    executor=user_proxy,
    name="icx_store_fact",
    description="Persists structured facts into ICX persistent memory."
)

user_proxy.initiate_chat(analyst, message="Persist our new zero-hallucination routing rule: sigma^-3 + sigma^-4 = 1.")

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://icx.caleralabs.com/mcp"),
  { requestInit: { headers: { "X-License-Key": "clabs_live_YOUR_KEY" } } }
);

const mcpClient = new Client({ name: "claude-icx-memory-agent", version: "1.1.0" }, { capabilities: {} });
await mcpClient.connect(transport);

const tools = await mcpClient.listTools();
console.log("Connected to Calera ICX Tools:", tools.tools.map(t => t.name));

const result = await mcpClient.callTool({
  name: "icx_recall_scoped",
  arguments: { query: "What are our RFC 2026 system architecture invariants?" }
});
console.log("Persistent Recall:", result);

import { chromium } from "playwright";

async function runICXWebMCPAgent() {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  const page = await context.newPage();

  // Navigate to ICX WebMCP surface
  await page.goto("https://icx.caleralabs.com/webmcp-docs");

  // Execute ICX WebMCP tool directly in the browser's modelContext
  const result = await page.evaluate(async () => {
    const harness = (window as any).__calera_webmcp;
    
    // Autonomously provision 1M memory nodes for human principal
    return await harness.executeTool("calera.icx.claim-1m-nodes", {
      principalEmail: "developer@caleralabs.com",
      agentName: "Playwright-Browser-Agent-01",
      primaryUseCase: "browser_memory",
      acceptA2bTerms: true
    });
  });

  console.log("In-Browser ICX WebMCP Result:", result);
  console.log("Vault ID:", result.vaultId);
  console.log("Cryptographic Proof Hash:", result.contractProof);

  await browser.close();
}

runICXWebMCPAgent();