# 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)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.graphlit.dev/readme.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.