# Platform Overview

Graphlit is the context layer for AI agents. We give developers complete infrastructure to build production AI applications with organizational knowledge — entities, relationships, and temporal state.

## Quick Reference

| Concept                | Description                                                                                        | Learn More                                                |
| ---------------------- | -------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| **Feeds**              | **Automatic sync from 30+ sources** (Slack, Gmail, GitHub, S3, RSS, etc.) - Unique to Graphlit     | [Feeds](/platform/feeds.md)                               |
| **Content**            | Documents, audio transcription, video analysis, web crawling                                       | [Ingestion Guide](/api-guides/use-cases/content.md)       |
| **Advanced Filtering** | **Production-grade queries**: geo-spatial, image similarity, entity-based, temporal, boolean logic | [See Examples](#production-grade-metadata-filtering)      |
| **Workflows**          | **Custom extraction pipelines** with vision models, OCR, entity extraction - Unique depth          | [Workflows](/platform/key-concepts.md#workflows)          |
| **Conversations**      | RAG with streaming, citations, and tool calling                                                    | [AI Agents Tutorial](/tutorials/ai-agents.md)             |
| **Knowledge Graph**    | Schema.org entities + relationships + temporal context                                             | [Knowledge Graph Tutorial](/tutorials/knowledge-graph.md) |
| **Specifications**     | Reusable model configurations (GPT-4, Claude, Gemini, Deepseek, etc.)                              | [AI Models](/platform/models.md)                          |
| **Collections**        | Flexible content grouping (virtual folders, topics, projects, users/teams)                         | [Key Concepts](/platform/key-concepts.md#collections)     |

***

{% hint style="success" %}
**Start here roadmap:**

1. [Sign up for Graphlit](/account-setup-one-time/signup.md)
2. [Create your first project](/account-setup-one-time/create-project.md)
3. [Copy credentials and run `hello.ts`](/account-setup-one-time/credentials.md#verify-your-setup)
4. Continue to [Quickstart: Your First Agent](/getting-started/quickstart.md)
   {% endhint %}

## What is a Context Layer?

A context layer gives AI agents the ability to understand entities, relationships, and temporal state - not just retrieve similar documents.

**The key difference**: RAG retrieves text chunks by similarity. A context layer knows "Alice from Acme Corp mentioned pricing on Oct 15" and can answer "What did Alice say about pricing?"

[Deep dive: Semantic Memory architecture →](/platform/semantic-memory.md)

***

## What Makes Graphlit Different

Graphlit provides a complete data platform for production AI applications - from ingestion to processing to retrieval.

### 🔌 30+ Data Connectors

Connect to any data source with one API call. OAuth, API keys, or bot tokens - we handle authentication for you.

**Communication:** Slack, Microsoft Teams, Discord\
**Email:** Gmail, Outlook\
**Project Management:** Jira, Linear, GitHub Issues, Trello\
**Documents:** Google Drive, OneDrive, SharePoint, Dropbox, Box, Notion\
**Cloud Storage:** AWS S3, Azure Blob, Google Cloud Storage\
**Meetings:** Fireflies.ai, Fathom, Attio Meetings, Salesforce ECI\
**CRM & Contacts:** Salesforce CRM, Attio CRM, Google Contacts, Microsoft Contacts\
**Research:** Parallel Research, Parallel Entity Discovery\
**Social:** Twitter, Reddit, YouTube\
**Calendars:** Google Calendar, Outlook Calendar\
**Support:** Zendesk, Intercom\
**Web:** RSS feeds, web crawling, site maps

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

const client = new Graphlit();

// Create Slack feed with bot token
const feed = await client.createFeed({
  name: 'Team Slack',
  type: FeedTypes.Slack,
  slack: {
    type: FeedListingTypes.Past,
    token: process.env.SLACK_BOT_TOKEN,  // Bot token from Slack app
    channel: 'general'  // Channel name or ID
  }
});
```

**What this means:** Connect any data source with a single API call. Authentication (OAuth, API keys, bot tokens), sync scheduling, data parsing, and indexing all handled automatically.

### 🎥 Multi-Format Processing

**Audio:** Automatic transcription with speaker diarization (Speaker #1, #2, etc.) via Deepgram, AssemblyAI\
**Video:** Audio extraction + transcription (available today), frame analysis coming soon (TwelveLabs, Azure Video Indexer)\
**Documents:** OCR with vision models, layout preservation\
**Web:** Crawling, screenshots, search integration (Tavily, Exa)\
**Email:** Parse and index with attachments\
**Code:** Repository indexing with GitHub connector

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

const client = new Graphlit();

// Transcribe audio with one call
const audio = await client.ingestUri(
  'https://example.com/meeting.mp3',
  'Team Meeting'
);
```

**Result:** Automatic transcription with speaker diarization (Speaker #1, Speaker #2, etc.), searchable transcript indexed for retrieval.

### ⚙️ Custom Workflows

**Most content doesn't need workflows** - Graphlit's intelligent defaults handle PDFs, audio, web pages automatically.

**When you need workflows:** Entity extraction for knowledge graphs.

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

const client = new Graphlit();

// Build knowledge graph from your documents
const workflow = await client.createWorkflow({
  name: 'Extract Entities',
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,  // Extract entities with LLM
        extractedTypes: [
          ObservableTypes.Person,           // People mentioned
          ObservableTypes.Organization,     // Companies, teams
          ObservableTypes.Label             // Topics, themes, tags
        ]
      }
    }]
  }
});
```

**Result:** Content is automatically prepared (PDFs, audio, web pages), then entities are extracted. Search by person ("all mentions of Alice"), organization ("documents about Acme Corp"), or label/topic.

**For complex PDFs only:** Add preparation stage with vision models. See [Workflows documentation](/platform/workflows.md) for advanced options.

### 🔄 Automatic Sync

Continuous polling from all connected sources (30 seconds to hours, configurable). After feed creation, data flows automatically - no manual polling, no webhooks to manage, no API rate limits to handle.

### 🎨 Publishing Capabilities

**Audio Generation:** Text-to-speech with ElevenLabs\
**Summaries:** Automatic content summarization\
**Markdown Export:** Structured content extraction\
**Citations:** Entity-linked, contextualized references

```typescript
import { Graphlit } from 'graphlit-client';
import { ContentPublishingFormats, ContentPublishingServiceTypes, FileTypes } from 'graphlit-client/dist/generated/graphql-types';

const client = new Graphlit();

// Publish markdown summaries of all document content
const published = await client.publishContents(
  "Create a concise summary",
  { type: ContentPublishingServiceTypes.Text, format: ContentPublishingFormats.Markdown },
  undefined,  // summaryPrompt
  undefined,  // summarySpecification
  undefined,  // publishSpecification
  undefined,  // name
  { fileTypes: [FileTypes.Document] }  // filter: only documents
);
```

**What this enables:** Transform and republish content. Generate audio versions, create summaries, export structured data. Your knowledge base becomes a content creation engine.

### 🔍 Production-Grade Metadata Filtering

Graphlit provides advanced filtering that would take weeks to build yourself - geo-spatial, image similarity, entity-based, temporal, and complex boolean queries all in one API:

**Search by Location** (geo-spatial queries)

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

const client = new Graphlit();

// Find all content within 10km of San Francisco
const results = await client.queryContents({
  search: 'restaurant reviews',
  location: { latitude: 37.7749, longitude: -122.4194, distance: 10000 }
});
```

**Search by Image** (visual similarity)

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

const client = new Graphlit();

// Find similar images
const imageBuffer = fs.readFileSync('./reference-image.jpg');
const base64Image = imageBuffer.toString('base64');

const similar = await client.queryContents({
  imageData: base64Image,
  imageMimeType: 'image/jpeg',
  numberSimilar: 20
});
```

**Search by Entity** (extracted people, orgs, places)

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

const client = new Graphlit();

// Find all content mentioning specific people or organizations
const mentions = await client.queryContents({
  search: 'product launch',
  observations: [
    { observable: { name: 'Kirk Marple' }},
    { observable: { name: 'Graphlit' }}
  ]
});
```

**Complex Boolean Queries** (AND/OR logic)

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

const client = new Graphlit();

// Find content created last 7 days mentioning "deal closure"
const results = await client.queryContents({
  search: 'deal closure',
  createdInLast: 'P7D'  // ISO 8601 duration: 7 days
});
```

**What this means:** Filter by location (find content near you), by visual similarity (find images like this one), by entities (all mentions of a person/company), by time (last 24 hours, date ranges), or combine filters. This level of filtering is typically only found in enterprise search systems.

### 🎬 True Multimodal Processing

Graphlit processes audio and video content - not just stores files, but actually extracts and indexes the content:

**Audio Files (MP3, WAV, M4A, etc.)**

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

const client = new Graphlit();

// Upload audio, get searchable transcript
const audio = await client.ingestUri(
  'https://example.com/podcast-episode.mp3',
  'Podcast Episode'
);
```

**Result:** Searchable transcript with speaker diarization (Speaker #1, Speaker #2, etc.).

**Video Files (MP4, MOV, etc.)**

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

const client = new Graphlit();

// Upload video, extract and transcribe audio
const video = await client.ingestUri(
  'https://example.com/product-demo.mp4',
  'Product Demo Video'
);
```

**Result:** Searchable transcript of audio track. Frame analysis coming soon (TwelveLabs, Azure Video Indexer).

**What this means:** Upload media files and immediately search their content. Meeting recordings become searchable transcripts with speaker identification (Speaker #1, #2, etc.). Product videos' audio becomes fully searchable. No separate transcription services needed.

***

## Why Graphlit?

Graphlit saves you 3-20 months of integration work and $160k-400k in Year 1 by providing complete data infrastructure for AI agents.

[See detailed TCO and competitive comparison →](/why-graphlit.md)

***

## AI Models

Graphlit supports 100+ LLMs including GPT-5, Claude 4.5 Sonnet, Gemini 2.5 Pro, Deepseek Reasoner, and more.

[Complete model reference and comparison →](/platform/models.md)

***

## Data Connectors

30+ feeds including Slack, Gmail, GitHub, Notion, Linear, Jira, Google Drive, OneDrive, S3, RSS, and more. Automatic sync with OAuth, API keys, or public sources.

[Browse all feeds and setup guides →](/platform/feeds.md)

***

## MCP-Native Integration

Bring Graphlit into Cursor, Windsurf, Claude Desktop, or VS Code - query your Slack, Gmail, Notion, and 30+ other sources directly from your IDE.

Install: `npx -y graphlit-mcp-server`

[Complete MCP setup guide →](/mcp-integration/mcp-integration.md)

***

## What You Can Build

**AI agents with memory** - Customer support, sales assistants, engineering agents with persistent context\
**Production SaaS apps** - Multi-tenant platforms ([Zine](https://www.zine.ai) runs on Graphlit with thousands of users)\
**Knowledge extraction** - Automatically extract entities, relationships, timelines from unstructured content

[See tutorials →](/getting-started/quickstart.md) | [Zine case study →](/examples/zine-case-study.md)

***

## Developer Experience

### 60+ Working Examples

Explore the sample gallery with working code you can run immediately:

* **Google Colab notebooks** - Run in browser, no setup
* **Next.js applications** - Deploy to Vercel
* **Streamlit apps** - Python UI examples
* **.NET console apps** - C# examples

[Browse sample gallery →](https://github.com/graphlit/graphlit-samples)

### Ask Graphlit

Get instant code examples and answers from our AI code assistant.

* Generate SDK code from descriptions
* Get best practices
* Find relevant examples
* Troubleshoot issues

[Use Ask Graphlit →](/resources/ask-graphlit.md)

***

## Security & Scale

### Enterprise Security

* **Encryption at rest** - All data encrypted using AES-256
* **Per-user data isolation** - Multi-tenant with user scoping
* **Project-level access** - Managed via Developer Portal
* **SOC 2** - Compliance coming soon
* **API authentication** - JWT-based secure access

### Built for Scale

* **Serverless architecture** - Auto-scaling infrastructure
* **Global deployment** - Low latency worldwide
* **Usage-based pricing** - Pay only for what you use
* **No infrastructure** - We handle operations

**Production proof:** Zine runs on Graphlit with thousands of users, automatic sync across 20+ data sources, and millions of documents.

***

## Pricing

**Free to get started** - No credit card required.

* **Free Tier**: 100 credits, 1GB storage, unlimited conversations
* **Hobby**: $49/month + usage
* **Starter**: $199/month + usage (10% off)
* **Growth**: $999/month + usage (20% off)

[View detailed pricing →](https://www.graphlit.com/#pricing)

***

## Need Help?

**Community & Support:**

* [**Discord**](https://discord.gg/ygFmfjy3Qx) - Community support, fastest response time
* [**Ask Graphlit**](/resources/ask-graphlit.md) - AI code assistant trained on Graphlit
* [**GitHub Issues**](https://github.com/graphlit/graphlit-client-python/issues) - Report bugs and feature requests
* **Email** - <support@graphlit.com> for direct support

***

## About Graphlit

We're building the context layer infrastructure for AI applications and agents.

**Our mission:** Give every developer the tools to build production AI apps and agents with organizational knowledge.

**Products:**

* **Graphlit** - Context layer for AI agents
* **Zine** - Team memory built on Graphlit ([zine.ai](https://www.zine.ai))

**Connect:** [Website](https://www.graphlit.com) • [Twitter](https://twitter.com/graphlit) • [LinkedIn](https://www.linkedin.com/company/graphlit) • [YouTube](https://www.youtube.com/@Graphlit) • [Blog](https://www.graphlit.com/blog)


---

# 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/getting-started/overview.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.