# What is Graphlit?

**The context layer for AI agents**

Give your AI agents the context they need to work reliably. One API for ingestion, extraction, storage, and retrieval - organizational knowledge with entities, relationships, and temporal state.

## What is Graphlit?

Graphlit is the **context layer for AI agents** - providing organizational knowledge infrastructure, data ingestion from 30+ sources, and intelligent retrieval. Whether you're building with Mastra, Agno, Vercel AI SDK, or custom code, Graphlit handles the hard parts so you can focus on your agent's logic and UX.

{% hint style="info" %}
**🔌 Works with your framework**: Use Graphlit's [MCP server](https://docs.graphlit.dev/mcp-integration/mcp-integration) to give any MCP-enabled framework instant access to 30+ feeds, audio/video processing, semantic search, and knowledge graphs. Or use our TypeScript/Python/C# SDKs directly.
{% endhint %}

**Context layer vs traditional RAG:**

| Feature             | Traditional RAG                      | Graphlit Context Layer                        |
| ------------------- | ------------------------------------ | --------------------------------------------- |
| **Memory**          | Stateless (forgets between sessions) | Persistent organizational memory              |
| **Understanding**   | Text chunk retrieval                 | Entities + relationships + temporal state     |
| **Recall**          | Keyword/similarity matching          | Graph traversal + semantic search             |
| **Knowledge**       | Document vectors only                | Knowledge graph + vectors                     |
| **Infrastructure**  | 7+ services to integrate             | Complete platform (one API) + MCP integration |
| **Processing**      | Manual pipeline setup                | Automatic extraction workflows                |
| **Personalization** | None (treats all users the same)     | Per-user knowledge graphs                     |
| **Citations**       | Basic text snippets                  | Entity-linked with provenance                 |

Think of it this way: RAG is like searching through filing cabinets. A context layer is like having a knowledgeable assistant who understands your organization.

## Why Developers Choose Graphlit

### The Problem

Building data infrastructure for AI agents means integrating:

* Vector database (Pinecone, Weaviate)
* Document parsers (Unstructured, LlamaParse)
* Entity extraction (spaCy, custom LLMs)
* Embedding models (OpenAI, Cohere)
* Storage (S3, Azure Blob)
* Search (Elasticsearch)
* OAuth connectors for data sources (Slack, Gmail, etc.)
* Sync infrastructure (polling, webhooks, rate limits)

**Result**: 3-20 months of integration work before building your actual agent application.

### The Graphlit Solution

```typescript
import { Graphlit } from 'graphlit-client';

async function main() {
  const graphlit = new Graphlit();

  // Ingest a document
  const content = await graphlit.ingestUri(
    'https://arxiv.org/pdf/1706.03762.pdf',
    'Attention Paper',
    undefined,
    undefined,
    true  // Wait for processing
  );

  // Ask questions about it
  const conversation = await graphlit.createConversation({
    name: 'Q&A Session',
    filter: { contents: [{ id: content.ingestUri.id }] }
  });

  const answer = await graphlit.promptConversation(
    'What are the key innovations?',
    conversation.createConversation.id
  );

  console.log(answer.promptConversation.message?.message);
}

main();
```

**One API. No assembly required.**

***

## Complete Platform Features

Graphlit provides everything you need to build production AI applications - from data ingestion to advanced processing:

| Capability              | Memory-Only Platforms                 | Graphlit                                                                                |
| ----------------------- | ------------------------------------- | --------------------------------------------------------------------------------------- |
| **Data Feeds**          | Manual ingestion                      | **30+ feeds** (Slack, Gmail, GitHub, S3, RSS, etc.) - OAuth, API keys, or public        |
| **Automatic Sync**      | Manual upload                         | **Continuous polling** (30 sec to hours, configurable per feed)                         |
| **Audio Processing**    | Basic or not available                | **Transcription + speaker diarization** (Speaker #1, #2, etc.) via Deepgram, AssemblyAI |
| **Video Processing**    | Not available                         | **Audio extraction + transcription** (available) + frame analysis (coming soon)         |
| **Document Processing** | Text extraction                       | **Vision OCR + layout preservation** (handles complex tables, diagrams)                 |
| **Web Capabilities**    | Not available                         | **Web crawling, screenshots, search integration** (Tavily, Exa)                         |
| **Workflows**           | Fixed pipeline                        | **Customizable multi-stage pipelines** (preparation + extraction stages)                |
| **Publishing**          | Retrieval only                        | **Audio generation, summaries, Markdown export** (TTS, content transformation)          |
| **Knowledge Graph**     | Vectors only (some have basic graphs) | **Schema.org entities + relationships** with temporal context                           |
| **Search Types**        | Vector similarity                     | **Hybrid: vector + graph + keyword**                                                    |
| **Advanced Filtering**  | Basic metadata filters                | **Geo-spatial, image similarity, entity-based, temporal, boolean (AND/OR)**             |
| **Production Features** | Basic user scoping                    | **Per-user isolation (userId parameter), collections, specifications**                  |

**Real example:** Building a Slack assistant with Graphlit vs memory-only platforms:

**With Graphlit:**

```typescript
// 1. Setup OAuth connector (one-time)
const feed = await graphlit.createFeed({
  name: 'Team Slack',
  type: FeedTypes.Slack,
  slack: { type: FeedListingTypes.Past }
});
// ✅ All messages automatically synced, indexed, and searchable
```

**With Memory-Only Platform:**

```typescript
// 1. Build Slack OAuth integration yourself
// 2. Poll Slack API yourself
// 3. Handle rate limits yourself  
// 4. Parse messages yourself
// 5. Upload to memory platform
// 6. Repeat for every data source
// ❌ Weeks of integration work per connector
```

**The difference:** Graphlit provides a complete platform - from data ingestion through processing to retrieval - so you can focus on building your application.

***

## What Can You Build?

### AI Agents with Memory

Customer support agents that remember every interaction and have full context from past conversations.\
→ [Build an agent in 7 minutes](https://docs.graphlit.dev/getting-started/quickstart)

### Production SaaS Applications

[Zine](https://zine.ai) runs in production on Graphlit with growing user base and multi-source data sync.\
→ [See the architecture](https://docs.graphlit.dev/examples/zine-case-study)

### Knowledge Extraction Systems

Automatically extract people, organizations, and relationships from any content.\
→ [Extract knowledge graphs](https://docs.graphlit.dev/tutorials/knowledge-graph)

## Quick Start (TypeScript)

{% hint style="info" %}
**SDK availability**: Python, TypeScript, and .NET SDKs available. All quickstart examples use TypeScript. Click "Convert to Python/​.NET" links throughout for instant language conversion via [Ask Graphlit](https://docs.graphlit.dev/resources/ask-graphlit).
{% endhint %}

{% hint style="success" %}
**Launch checklist:**

1. [Sign up](https://docs.graphlit.dev/account-setup-one-time/signup) (30 seconds)
2. [Create project](https://docs.graphlit.dev/account-setup-one-time/create-project) (1 minute)
3. [Get credentials](https://docs.graphlit.dev/account-setup-one-time/credentials) (1 minute)
4. ✅ **Verify setup**: Run `hello.ts` (Step 1 below)
5. [Quickstart: Your First Agent](https://docs.graphlit.dev/getting-started/quickstart) (7 minutes)
   {% endhint %}

**Key terms you'll use:**

* **Content** – anything you've ingested (files, web pages, emails)
* **Conversation** – AI session that remembers prior messages and retrieved context
* **Specification** – which LLM + settings to use (model, temperature, etc.)

### 1. Say Hello to Graphlit

Verify your credentials work:

```typescript
import { Graphlit } from 'graphlit-client';

const graphlit = new Graphlit();

async function main() {
  const project = await graphlit.getProject();
  console.log(`✅ Connected: ${project.project.name}`);
}

main();
```

Run: `npx tsx hello.ts`

### 2. Ingest & Search

```typescript
import { Graphlit } from 'graphlit-client';
import { SearchTypes } from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

async function main() {
  // Ingest document
  const content = await graphlit.ingestUri(
    'https://arxiv.org/pdf/1706.03762.pdf',
    'Attention Paper',
    undefined,
    undefined,
    true, // Wait for processing
  );

  console.log(`✅ Document ready: ${content.ingestUri.id}`);

  // Hybrid search (vector + keyword)
  const results = await graphlit.queryContents({
    search: 'transformer innovations',
    searchType: SearchTypes.Hybrid,
  });

  console.log(`Found ${results.contents?.results?.length ?? 0} documents`);
}

main();
```

### 3. RAG Conversation

```typescript
import { Graphlit } from 'graphlit-client';

const graphlit = new Graphlit();

async function main() {
  const content = await graphlit.ingestUri(
    'https://arxiv.org/pdf/1706.03762.pdf',
    'Attention Paper',
    undefined,
    undefined,
    true,
  );

  const conversation = await graphlit.createConversation({
    name: 'Q&A Session',
    filter: { contents: [{ id: content.ingestUri.id }] },
  });

  const answer = await graphlit.promptConversation(
    'What are the key innovations?',
    conversation.createConversation.id,
  );

  console.log(answer.promptConversation.message?.message);
}

main();
```

{% hint style="success" %}
**Ready for more?** → [Quickstart: Add streaming and tool calling](https://docs.graphlit.dev/getting-started/quickstart)
{% endhint %}

## Production Ready

Graphlit handles production scale out of the box:

* **Multi-tenant**: Per-user data isolation within a single project (create users in Graphlit, scope SDK with userId)
* **Scale**: Built to handle thousands of users and millions of documents per project
* **Automatic sync**: Feed connectors poll on configurable schedules (30 seconds to hours)
* **Proof**: [Zine](https://zine.ai) runs on Graphlit in production

[Zine case study →](https://docs.graphlit.dev/examples/zine-case-study)

## Connect Your Data

30+ feeds (Slack, Gmail, GitHub, S3, RSS, and more) with automatic sync - [view all →](https://docs.graphlit.dev/platform/feeds)

## Next Steps

**🚀 Start here**: [Quickstart: Your First Agent](https://docs.graphlit.dev/getting-started/quickstart) (7 minutes)\
Build a streaming agent with tool calling. Fastest way to see Graphlit in action.

**Then explore**:

* [AI Agents Tutorial](https://docs.graphlit.dev/tutorials/ai-agents) - Multi-agent patterns (15 min)
* [Knowledge Graph](https://docs.graphlit.dev/tutorials/knowledge-graph) - Entity extraction (20 min)

**Need help?**

* [Discord Community](https://discord.gg/ygFmfjy3Qx) - Active developer community
* [Ask Graphlit](https://ask.graphlit.dev) - AI code assistant
* [60+ Examples](https://github.com/graphlit/graphlit-samples) - Working code

***

Built by [Graphlit](https://www.graphlit.com) • [Sign up free](https://portal.graphlit.dev)