Quick Start

Get up and running with GraphRAG SDK in 5 minutes.

Installation

pnpm add graphrag-sdk @graphrag-sdk/lexical @graphrag-sdk/in-memory-storage ai @ai-sdk/openai

Basic Example

import { createGraph, query } from "graphrag-sdk";
import { lexicalGraph, chunkEntityGeneration, naiveSearch } from "@graphrag-sdk/lexical";
import { inMemoryGraph, inMemoryVector, inMemoryKV } from "@graphrag-sdk/in-memory-storage";
import { openai } from "@ai-sdk/openai";

const graph = createGraph({
  graph: lexicalGraph({
    graphStoreFactory: inMemoryGraph,
    vectorStoreFactory: inMemoryVector,
    kvStoreFactory: inMemoryKV,
    pipeline: [chunkEntityGeneration()],
  }),
  model: openai("gpt-4o-mini"),
  embedding: openai.embedding("text-embedding-3-small"),
  namespace: "my-project",
});

// Insert documents
await graph.insert([
  "GraphRAG SDK is a TypeScript library for building graph-enhanced RAG systems.",
  "It supports entity extraction, community detection, and multiple search strategies.",
]);

// Query the graph
const { text } = await query({
  graph,
  search: naiveSearch({ topK: 5 }),
  prompt: "What is GraphRAG SDK?",
});
console.log(text);

Step-by-Step Walkthrough

1. Import Dependencies

import { createGraph, query } from "graphrag-sdk";
import {
  lexicalGraph,
  chunkEntityGeneration,
  entityCommunityGeneration,
  naiveSearch,
  entityEnhancedSearch,
  globalCommunitySearch,
  localCommunitySearch,
} from "@graphrag-sdk/lexical";
import { inMemoryGraph, inMemoryVector, inMemoryKV } from "@graphrag-sdk/in-memory-storage";
import { openai } from "@ai-sdk/openai";

2. Configure Your Graph

The graph is built from three parts: a provider (with a processing pipeline), models, and a namespace.

const graph = createGraph({
  // Provider — defines how the graph is built and what's stored
  graph: lexicalGraph({
    graphStoreFactory: inMemoryGraph,
    vectorStoreFactory: inMemoryVector,
    kvStoreFactory: inMemoryKV,

    // Pipeline — composable processors that run during insert
    pipeline: [
      chunkEntityGeneration({
        entityTypes: ["person", "organization", "location", "event"],
      }),
      entityCommunityGeneration({ algorithm: "leiden" }),
    ],
  }),

  // LLM for generating answers and extracting entities
  model: openai("gpt-4o-mini"),

  // Embedding model for vector search
  embedding: openai.embedding("text-embedding-3-small"),

  // Namespace for multi-tenancy isolation
  namespace: "techcorp",
});

3. Insert Documents

// Single document
await graph.insert("Your text content...");

// Multiple documents
await graph.insert([
  "TechCorp is a leading AI company based in San Francisco.",
  "Sarah Chen serves as the CEO of TechCorp.",
  "TechCorp partnered with GlobalBank to implement LinguaAI.",
]);

// With metadata
await graph.insert({
  content: "Document content...",
  metadata: { source: "https://example.com" },
});

4. Query with Search Strategies

Each search strategy retrieves context differently. query() runs the strategy, then passes context to the LLM for answer generation.

// Naive search — pure vector similarity on chunks
const { text } = await query({
  graph,
  search: naiveSearch({ topK: 10 }),
  prompt: "Tell me about LinguaAI",
});

// Global community search — thematic/summary questions
const { text: themes } = await query({
  graph,
  search: globalCommunitySearch({ topK: 3 }),
  prompt: "What are the major themes?",
});

// Entity-enhanced search — chunks enriched with graph context
const { text: enhanced } = await query({
  graph,
  search: entityEnhancedSearch({ topK: 5, maxDepth: 2 }),
  prompt: "How is Sarah Chen connected to TechCorp?",
});

// Local community search — entity neighborhoods + community reports
const { text: entity } = await query({
  graph,
  search: localCommunitySearch(),
  prompt: "Who is Sarah Chen?",
});

Composable Pipeline

The key innovation is the composable pipeline. Each processor builds on what previous processors created:

import {
  chunkEntityGeneration,
  entityCommunityGeneration,
  similarChunkConnection,
  hypotheticalQuestionGeneration,
} from "@graphrag-sdk/lexical";

// Full pipeline — all processors
const graph = createGraph({
  graph: lexicalGraph({
    graphStoreFactory: inMemoryGraph,
    vectorStoreFactory: inMemoryVector,
    kvStoreFactory: inMemoryKV,
    pipeline: [
      chunkEntityGeneration(),                          // chunks → entities
      entityCommunityGeneration(),                      // entities → communities
      similarChunkConnection({ similarity: 0.7 }),      // chunks ↔ similarity edges
      hypotheticalQuestionGeneration({ questionsPerChunk: 3 }), // chunks → questions
    ],
  }),
  model: openai("gpt-4o-mini"),
  embedding: openai.embedding("text-embedding-3-small"),
});

// Each search strategy leverages different parts of the pipeline
await query({ graph, search: naiveSearch(), prompt: "..." });                    // chunks only
await query({ graph, search: entityEnhancedSearch(), prompt: "..." });           // needs chunkEntityGeneration
await query({ graph, search: localCommunitySearch(), prompt: "..." });           // needs entityCommunityGeneration
await query({ graph, search: globalCommunitySearch(), prompt: "..." });          // needs entityCommunityGeneration
await query({ graph, search: similarChunkTraversalSearch(), prompt: "..." });    // needs similarChunkConnection
await query({ graph, search: hypotheticalQuestionSearch(), prompt: "..." });     // needs hypotheticalQuestionGeneration

Using Presets

Presets are pre-configured pipelines matching well-known GraphRAG implementations:

import { microsoftGraphragPreset, lightragPreset } from "@graphrag-sdk/lexical";

// Microsoft GraphRAG — entities + communities
const graph = createGraph({
  graph: lexicalGraph({
    ...microsoftGraphragPreset(),
    graphStoreFactory: inMemoryGraph,
    vectorStoreFactory: inMemoryVector,
    kvStoreFactory: inMemoryKV,
  }),
  model: openai("gpt-4o-mini"),
  embedding: openai.embedding("text-embedding-3-small"),
});

// LightRAG — entities only, no communities
const graph2 = createGraph({
  graph: lexicalGraph({
    ...lightragPreset(),
    graphStoreFactory: inMemoryGraph,
    vectorStoreFactory: inMemoryVector,
    kvStoreFactory: inMemoryKV,
  }),
  model: openai("gpt-4o-mini"),
  embedding: openai.embedding("text-embedding-3-small"),
});

External Storage

For production, swap in external databases:

import { neo4jGraph } from "@graphrag-sdk/neo4j";
import { qdrantVector } from "@graphrag-sdk/qdrant";
import { redisKV } from "@graphrag-sdk/redis";

const graph = createGraph({
  graph: lexicalGraph({
    graphStoreFactory: (ns) => neo4jGraph({ uri: "bolt://localhost:7687", namespace: ns }),
    vectorStoreFactory: (ns) => qdrantVector({ url: "http://localhost:6333", collection: ns }),
    kvStoreFactory: (ns) => redisKV({ url: "redis://localhost:6379", prefix: ns }),
    pipeline: [chunkEntityGeneration(), entityCommunityGeneration()],
  }),
  model: openai("gpt-4o-mini"),
  embedding: openai.embedding("text-embedding-3-small"),
  namespace: "production",
});

Clean Up

await graph.close();

Next Steps

• Core Concepts - Understand the architecture
• API Reference - Complete API documentation
• Storage - Configure storage backends