Knowledge Graph

Connect the facts behind the answer.

A knowledge graph connects facts: who owns a project, which customer reported an issue, and how they relate. Minds keeps those connections and their history, so your agent can look beyond an isolated search result.

Start free Read the docs

Knowledge graph

Facts connect.
Context takes shape.

See who, what, and when. Follow the relationship back to the fact behind it.

Relationship explorer

Who owns the launch?

Find the connectionLaunch → ownerFollow a fact to its source.

Launch plan · September 4

MINDS / KNOWLEDGE GRAPHIllustrated example

Who owns the launch?

A name in a document is one detail. Connecting that name to the work makes it useful.

Choose a step to explore

History with context

An answer can change. Its history should stay.

Alice changes teams in March, but your agent learns about it in April. Minds records both dates. Ask who managed Alice in March, or what your agent knew before the update. This is a bi-temporal graph: one timeline for the world, another for when the information arrived.

When it happened

Alice joined her new team on March 1. Valid time records when that relationship applies, even if you enter it later.

When you learned it

The update arrived on April 3. Transaction time preserves when Minds recorded it, so you can reconstruct what was known at an earlier date.

Build with the graph

Follow the connections behind a question.

Find a person, follow their relationships, or rank connected entities by importance. Use Cypher, a query language for graphs, to describe the connections you want to find. Named contexts, called microtheories, let you organize knowledge for a particular domain.

Query relationships in an existing graphtypescript

// Run server-side with credentials scoped to this Mind.
const endpoint = process.env.AKASHA_URL;
const capability = process.env.AKASHA_CAPABILITY;
if (!endpoint || !capability) throw new Error("Configure your Mind connection");

async function request(method: string, path: string, body?: unknown) {
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "x-akasha-capability": capability!,
  };
  if (process.env.AKASHA_TOKEN) {
    headers.Authorization = "Bearer " + process.env.AKASHA_TOKEN;
  }
  const response = await fetch(new URL(path, endpoint), {
    method, headers,
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  if (!response.ok) throw new Error("Mind request failed: " + response.status);
  return response.json();
}

const { rows } = await request("POST", "/v1/graph/cypher", {
  query: "MATCH (n:Person)-[r:KNOWS]->(m:Person) RETURN n.name, m.name",
});

Source integrity

Keep a way to check the original.

Create a cryptographic fingerprint for an imported batch and check its integrity later. Keep that check alongside source information, so your team can assess both the record and where it came from.

Technical details

Relationships you can query through time.

People, projects, and facts are nodes. The connections between them are edges. Both can carry properties and dates that describe when they apply.

Graph

Data model: Nodes, edges, and their properties
History: Valid time + transaction time
Queries: Cypher, entity search, and PageRank
Named contexts: Microtheories
Batch integrity: SHA-256 Merkle proofs

Keep exploring

Reasoning

Combine pattern matching with relationships your agent can inspect.

Vector + SQL

Memory

Keep experiences and sources available across sessions.

Connect the facts your agents work with.

Start with the people, projects, and relationships that matter to your work. Give your agent a history it can return to.

Start free View pricing