RAG + Graph + Memory

An MIT-licensed TypeScript context layer backed by Postgres and pgvector.

Runs in your stack

TypeGraph is MIT-licensed and runs in your application against Postgres and pgvector.

One SDK, one path, one Postgres database. Stop stitching together fragmented context pipelines, memory systems and multiple databases.

Send your data, search it with hybrid retrieval, and build persistent memory for your agents. TypeGraph is a focused primitive - it stores, indexes, and retrieves so you can focus on building.

Your Application

TypeGraph

Ingest ↓

Chunking

Entity Extraction

Embedding

↑↓Query

Ranking

Query Construction

Embedding

Policies · Key Permissions·EventSink · OTel

Postgres

Vectors · Documents · Graph

Typescript

One SDK for ingest, retrieval, and memory

Connect any data source, chunk and embed content automatically, and retrieve the most relevant context for your LLMs with a single unified interface.

Ingest

import { gateway } from '@ai-sdk/gateway'
import { neon } from '@neondatabase/serverless'
import { PgVectorAdapter } from '@typegraph-ai/adapter-pgvector'
import { TenantId, typegraphDeploy, typegraphInit } from '@typegraph-ai/sdk'

const embedding = {
  model: gateway.embeddingModel('openai/text-embedding-3-small'),
  dimensions: 1536,
}
const config = {
  tenantId: TenantId('tenant_acme'),
  vectorStore: new PgVectorAdapter({
    sql: neon(process.env.DATABASE_URL!),
  }),
  embedding,
  searchEmbedding: embedding,
}

await typegraphDeploy(config)
const typegraph = await typegraphInit(config)

// Ingest support docs - chunking, embedding, and dedup are automatic
await typegraph.document.ingest(
  [{
    id: 'kb:refund-policy',
    name: 'Refund Policy',
    description: 'Return and refund timing for customer support.',
    content: 'Refunds are processed within 5-7 business days. Items must be returned in original condition within 30 days of purchase...',
  }],
  { graphExtraction: false },
)

Flexible by Design

Whether you're building a simple RAG application, or need a full-featured enterprise solution, TypeGraph is flexible enough to meet your needs. Ingest documents with automatic chunking, embedding, and deduplication. Content-hash-based change detection means re-ingesting is cheap - only new or modified content gets processed.

Simple RAG Guide ->Multi-Tenant RAG Guide ->

Observability

Open Telemetry-based metrics, tracing, health dashboard, session replay, temporal explorer ("what did the agent know when?"), memory influence tracking, query performance analytics and more.

Observability and Tracing Guide ->

Secure and Private

Built in scope isolation. Encryption at rest and in transit. Easily configure least-privilege PostgreSQL permissions for self-hosted TypeGraph deployments.

Database Permissions Guide ->

Typeless Buckets

Named containers that organize your data without rigid schemas. A single bucket can hold documents, events, and memory artifacts from any provider or format.

Content Deduplication

Hash-based change detection across ingestion runs. Re-ingest your entire corpus and only new or modified content gets processed and embedded.

Context Assembly

Assemble chunks, facts, entities, and memories into LLM-ready context with section controls, token budgets, and XML/markdown formatting built in.

Multi-tenancy

Built-in tenant isolation via tenantId scoping. Every document, event, memory, and search is automatically filtered to the correct tenant.

Knowledge Graph

Automatic entity extraction and relationship linking from documents, events, and thread turns. Search the semantic graph to surface connections your agents wouldn't otherwise find.

Temporal Memory

Temporal memory with automatic entity extraction, knowledge graph construction, and recency scoring. Your agents remember prompt context across sessions and threads.

Intelligent Embeddings

Use any AI SDK-compatible embedder - OpenAI, Cohere, local ONNX models, and more. Configure separate ingest and search embedders when your provider supports asymmetric retrieval.

Embeddings

// Each bucket can use a different ingest/search embedding pair
const support = await typegraph.bucket.create({
  name: 'support-tickets',
  embeddingModel: 'text-embedding-3-small',
  searchEmbeddingModel: 'text-embedding-3-small',
})

const policies = await typegraph.bucket.create({
  name: 'policies',
  embeddingModel: 'text-embedding-3-large',
  searchEmbeddingModel: 'text-embedding-3-large',
})

// Search across both with explicit scoring weights
const response = await typegraph.search('refund processing time', {
  buckets: [support.id, policies.id],
  resources: ['documents'],
  weights: { semantic: 1, bm25: 0.7 },
  limit: 10,
  fusion: { method: 'rrf', k: 60 },
})

for (const chunk of response.results.chunks) {
  console.log(chunk.document?.name, chunk.scores.output.fused)
}

Cognitive Memory for AI Agents

Give your agents persistent, structured memory that grows with every interaction.

What happened

Episodic

Timestamped events with session context. Auto-extracted from conversations. Decays naturally over time.

What is known

Semantic

Subject-predicate-object fact triples. Contradiction detection and resolution. Knowledge graph relationships.

How to do things

Procedural

Learned procedures from repeated patterns. Tracks success/failure rates. Promotes reliable patterns.

Memory

// Log the refund thread for persistent memory
await typegraph.thread.addTurn(
  'thread-refund-1234',
  {
    role: 'user',
    content: 'I need a refund for order #1234',
    timestamp: new Date(),
  },
  { context: { userId: 'cust-42', threadId: 'thread-refund-1234' } }
)

// Extract reusable memory artifacts from the stored conversation
await typegraph.memory.extractThread('thread-refund-1234', {
  context: { userId: 'cust-42' },
})

// Recall relevant memory as a formatted XML string
const memoryPrompt = await typegraph.memory.recall(
  'What refund requests has this customer made?',
  { context: { userId: 'cust-42' }, types: ['semantic', 'episodic'], format: 'xml' }
)

Knowledge Graph Intelligence

Automatically extract entities and relationships from your data. Visualize connections, discover patterns, and query your knowledge graph to surface insights.

Feed your data

Ingestion

Documents, events, threads, and structured data are automatically processed. Entity extraction identifies people, organizations, concepts, and more from unstructured text.

Discover connections

Extraction

Relationships between entities are automatically identified and linked. Subject-predicate-object triples form a semantic network that grows with every interaction.

Surface insights

Query

Traverse the graph to find connections your agents wouldn't otherwise discover. Combine graph traversal with vector search for context-aware retrieval.

Open source RAG infrastructure

Start building with TypeGraph today

Install the MIT-licensed SDK, connect Postgres with pgvector, and keep your context layer in your own stack.

View on GitHub ->Read the docs ->