ReasonGraph Cloud memory

ReasonGraph

A graph-based memory for AI agents: it ingests facts, auto-extracts entities and cause->effect relations, and discovers connections across independent documents *and* across agent sessions -- with conflict resolution, time-travel, causal tracing, and counterfactuals.

Why ReasonGraph?

Standard RAG retrieves documents similar to your query. ReasonGraph is a persistent, updatable memory that discovers connections *between* facts that were written independently.

When you feed text into add_texts(), ReasonGraph automatically extracts entities (via GLiNER) and cause-effect relations (via a dedicated causal model) that become nodes and typed edges in a graph. Facts that share entities or causal chains get connected -- even if they never reference each other. Multi-hop traversal then walks these connections to build reasoning chains that span multiple sources.

On top of retrieval it works as agent memory: scopes/sessions (agents discover into each other's memory through shared entities), contradiction resolution (a new fact soft-supersedes what it contradicts), time-travel (query(as_of=...)), causal tracing (trace_effects / root_causes / causal_chain), counterfactuals (what_if), and a shippable MemoryService over HTTP and MCP.

Zero config, strong defaults. ReasonGraph() picks the best available entity extractor, causal model, embedder, and reranker automatically -- the eval numbers below come from these defaults. For the SOTA causal model (~0.70 F1) use pip install reasongraph[causal] and the graph uses it automatically. The configuration sections are optional depth, not required reading.

Use it in 60 seconds

Claude Code / Cursor / any MCP client, hosted (EU, no LLM in the loop):

claude mcp add --transport http memory https://memory.primaxiom.ai/mcp \

--header "Authorization: Bearer rgm_YOUR_KEY"

Local MCP server (stdio, everything on your machine, SQLite):

pip install "reasongraph[service,gliner,fastembed,sqlite]"

claude mcp add memory -- reasongraph-mcp

Python, in-process:

pip install "reasongraph[all]"

from reasongraph import ReasonGraph

graph = ReasonGraph() graph.initialize_sync() graph.add_texts_sync(["TSMC is building a chip fab in Phoenix, Arizona.", "Arizona ordered water cuts for industrial users in Maricopa County."]) print(graph.discover_sync("water and chips")) # a path: water cuts -> Arizona -> TSMC fab

Any language, over HTTP (self-hosted or hosted):

curl -X POST https://memory.primaxiom.ai/sessions/notes/memory \

-H "Authorization: Bearer rgm_YOUR_KEY" -H "Content-Type: application/json" \ -d '{"text": "Apple sources M-series chips from TSMC in Arizona."}'

Ready-to-copy agents (Groq/OpenAI-compatible research agent, two agents sharing one memory, Claude Code with persistent memory, LangGraph) live in examples/agents/.

Hosted: ReasonGraph Cloud

memory.primaxiom.ai runs this library as a service: sign in, get a free key (10k requests a month), remote MCP endpoint, browser console and playground. Extraction runs with small models on servers PrimAxiom operates (currently in the EU); facts are only sent to an LLM provider if you ask for a synthesized answer. Early access.

JavaScript and TypeScript

Agents that are not written in Python talk to the hosted service through a dependency-free client (clients/typescript). It uses the platform fetch, so it runs on Node 18+, Bun, Deno, Cloudflare Workers and the browser. npm install reasongraph.

import { Memory, memoryTools } from "reasongraph";

const mem = new Memory({ apiKey: process.env.REASONGRAPH_API_KEY }); await mem.remember("scout", "TSMC is building a chip fab in Phoenix, Arizona."); const facts = await mem.discover("What could disrupt the Phoenix fab?");

memoryTools(mem) returns OpenAI-style tool definitions with their executors attached, for agents that call functions directly without a framework: remember, recall and why.

Installation

pip install reasongraph[all]        # everything included

Or install only what you need:

pip install reasongraph             # core: in-memory backend, NER extraction, embeddings

pip install reasongraph[gliner] # + GLiNER entity extraction + hybrid causal (default, recommended) pip install reasongraph[causal] # + SOTA span-pointer causal model (~0.70 F1) + hybrid fallback pip install reasongraph[gliner2] # + GLiNER2 alternative (single model does entities + causal) pip install reasongraph[sqlite] # + SQLite backend with sqlite-vec pip install reasongraph[postgres] # + PostgreSQL + pgvector backend pip install reasongraph[service] # + HTTP + MCP memory service pip install reasongraph[fastembed] # + pure-ONNX embedder / reranker (faster cold start)

Cross-Source Discovery

Two reports about different topics. Source A covers TSMC's semiconductor plant. Source B covers Arizona's water crisis. Neither mentions the other's subject.

import asyncio

from reasongraph import ReasonGraph

source_a = [ # Tech industry report "TSMC announced plans to build a $40 billion semiconductor fabrication plant in Phoenix, Arizona.", "The Phoenix fab requires 10 million gallons of purified water daily to cool wafers during the chip etching process.", "TSMC signed a long-term supply agreement with Apple to manufacture next-generation M-series processors at the Arizona facility.", "Construction delays at the Phoenix site pushed first production to late 2025, raising concerns among TSMC's major customers.", ]

source_b = [ # Environmental report -- never mentions TSMC, semiconductors, or chips "Arizona declared a water emergency after Lake Mead dropped to its lowest level since the 1930s, threatening water supply for millions.", "The Arizona Department of Water Resources ordered mandatory water cuts for all industrial users in Maricopa County, where Phoenix is located.", "Intel paused expansion of its Chandler, Arizona chip plant citing water availability concerns and rising operational costs.", "Apple warned investors that component shortages from its Asian and North American suppliers could impact iPhone production timelines through 2026.", ]

async def main(): async with ReasonGraph() as graph: await graph.add_texts(source_a) await graph.add_texts(source_b) results = await graph.query("How does the Arizona water crisis affect semiconductor manufacturing?") for i, text in enumerate(results, 1): source = "A" if text in source_a else "B" print(f"{i}. [Source {source}] {text}")

asyncio.run(main())

1. [Source B] Intel paused expansion of its Chandler, Arizona chip plant citing water availability concerns and rising operational costs.
2. [Source B] The Arizona Department of Water Resources ordered mandatory water cuts for all industrial users in Maricopa County, where Phoenix is located.
3. [Source A] The Phoenix fab requires 10 million gallons of purified water daily to cool wafers during the chip etching process.
4. [Source B] Arizona declared a water emergency after Lake Mead dropped to its lowest level since the 1930s.
5. [Source A] TSMC announced plans to build a $40 billion semiconductor fabrication plant in Phoenix, Arizona.
6. [Source A] TSMC signed a long-term supply agreement with Apple to manufacture M-series processors at the Arizona facility.

Results come from both sources. No single document contains this chain. Here is what happens under the hood:

ReasonGraph extracts entities and causal relations from each text (requires an entity+causal extractor, e.g. pip install reasongraph[gliner] or [all]):

Three entities appear in both sources, creating bridge nodes:

The query traversal path:

Water crisis query -> finds water-related texts from both sources via embeddings -> follows Arizona and Phoenix entity edges to discover TSMC's water-intensive fab -> follows Apple entity edge from TSMC supply agreement to Apple's component shortage warning. The causal relation Lake Mead dropped -> water emergency connects the environmental trigger to the industrial impact.

Full demo: uv run python examples/cross_source_discovery.py

Quick Start

Using a built-in dataset

from reasongraph import ReasonGraph

graph = ReasonGraph() graph.initialize_sync() graph.load_dataset_sync("financial")

results = graph.query_sync("What caused the 2008 financial crisis?") for i, text in enumerate(results, 1): print(f"{i}. {text}")

graph.close_sync()

Output -- a connected reasoning chain, not just keyword matches:

1. Lehman Brothers filed for bankruptcy in September 2008 after massive MBS losses.

1. Loose lending standards fueled a housing price bubble across the United States.
2. Lehman's collapse triggered a global credit freeze as interbank lending stopped.
3. Mortgage-backed securities built on subprime loans collapsed when defaults surged.
4. The U.S. government enacted TARP, a $700 billion bailout to stabilize the financial system.
5. Banks issued subprime mortgages to borrowers with poor credit histories.

Async API

import asyncio

from reasongraph import ReasonGraph

async def main(): async with ReasonGraph() as graph: await graph.load_dataset("financial") results = await graph.query("What caused the 2008 crisis?") for text in results: print(text)

asyncio.run(main())

Features

• Cross-source discovery -- connect facts across independent documents through shared entities and causal relations
• Automatic extraction -- entities (GLiNER gliner_small-v2.5 by default) and cause->effect relations (a dedicated span-pointer / hybrid causal model) are extracted on add, both on by default; falls back to GLiNER2 then BERT NER when gliner is not installed
• Agent memory -- scopes/sessions with cross-session discovery, contradiction resolution (soft-supersede), time-travel (as_of), semantic dedup, and auto-forget
• Causal reasoning -- trace downstream effects, root causes, and directed causal paths; ask counterfactual what_if
• Hybrid search -- combine embedding similarity, keyword (trigram) matching, or both
• *