TypeGraphTypeGraph
TypeGraph is open source

RAG + Graph + Memory

Deploy a context layer in just 5 minutes.

  • New Relic
  • Segment
  • Oper8r
  • Revdup
  • Decusoft

Cloud or Self-hosted

Either way, TypeGraph manages deployment.

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 { typegraphInit } from '@typegraph-ai/sdk'

// Cloud mode - just pass your API key
const typegraph = await typegraphInit({
  apiKey: process.env.TYPEGRAPH_API_KEY!,
  tenantId: process.env.TYPEGRAPH_TENANT_ID!,
})

// 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...',
  }]
)

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 ->
Feature 01

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 ->
Feature 02

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 ->
Feature 03

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.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' },
  { context: { userId: 'cust-42', threadId: 'thread-refund-1234' } }
)

// Recall facts extracted from past thread turns (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.

Pricing plans

Simple, transparent pricing

Start with pure RAG search, add cognitive memory for agentic workflows, or unlock the full knowledge graph. Scale as you grow.

Self Host

Free

Run the open-source TypeGraph SDK on your own infrastructure.

  • Open-source SDK
  • Bring your own database
  • Community support
  • Hybrid search
  • Cognitive memory
  • Knowledge graph
View SDK ->

Pay As You Go

Metered

Cloud-hosted TypeGraph with usage-based pricing for tokens, compute, and storage.

Ingest Embed Tokens
per M tokens
$0.12
Query Embed Tokens
per M tokens
$0.04
LLM Input Tokens
per M tokens
$1.00
LLM Output Tokens
per M tokens
$3.00
Compute Time
per CPU hour
$0.52
Data Storage
per GB-month
$1.40

Enterprise Consulting

Custom

Architecture, deployment, and implementation support for teams with custom requirements.

  • Custom usage commitments
  • Deployment architecture review
  • Dedicated implementation support
  • Custom security and compliance needs
Contact Us ->
Open source RAG infrastructure

Start building with TypeGraph today

Get started with the open-source SDK or let us handle the infrastructure with TypeGraph Cloud. Either way, your LLMs get the context they need.

TypeGraph - Context for Every LLM | TypeGraph