TypeGraphTypeGraph
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 ->
Getting started with TypeGraph

Everything you need to know

What is TypeGraph?

TypeGraph is a unified context SDK for LLM applications. It combines RAG (retrieval-augmented generation), persistent agent memory, and knowledge graph extraction into a single TypeScript SDK backed by Postgres. Instead of stitching together a vector database, a memory layer, and a graph store, you get one interface that handles ingestion, embedding, retrieval, and memory.

How does the RAG pipeline work?

You ingest documents and events via the SDK, and TypeGraph automatically chunks, embeds, and deduplicates the content-bearing records. At search time, hybrid retrieval combines semantic vectors with BM25 to find the most relevant content. Results can be assembled into LLM-ready prompts with token budgets and XML or Markdown formatting. Content-hash-based change detection means re-ingestion only processes new or modified content.

What is the knowledge graph feature?

TypeGraph automatically extracts entities (people, organizations, concepts, technologies, etc.) and their relationships from your data. These are stored as subject-predicate-object triples that form a queryable semantic graph. You can traverse the graph to surface connections that pure vector search would miss, and combine graph traversal with embedding-based retrieval for richer context.

How does agent memory work?

TypeGraph provides three types of cognitive memory for AI agents. Episodic memory stores timestamped events from conversations with automatic time-decay. Semantic memory captures facts as structured triples with built-in contradiction detection. Procedural memory learns from repeated patterns and tracks success/failure rates. All three are extracted automatically from conversation turns and can be recalled by user, session, or topic.

Can I self-host TypeGraph?

Yes. TypeGraph runs on a single Postgres database and can be deployed as a managed cloud service or self-hosted in your own infrastructure. The same SDK works in both modes - you just swap the connection config. Self-hosted deployments give you full control over data residency and network boundaries while using the exact same API.

What embedding models are supported?

TypeGraph supports any AI SDK-compatible embedding model including OpenAI, Cohere, and local ONNX models. You can assign different ingest and search embedders to different buckets, and TypeGraph handles dimension isolation and rank fusion. This means you can search across content embedded with different models in a single request.

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

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.

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.

Pricing | TypeGraph