Feeds

Graphlit connects to 30+ data sources with automatic sync. OAuth, API keys, or public sources.

API terminology: In the Graphlit API, these are called feeds (you create them with createFeed()).

Feed = A connection that continuously syncs data from a source (Slack, S3, RSS, etc.) Connector = Optional per-user auth credential storage (smaller, used with feeds)

Authentication: Feeds support OAuth (Slack, Gmail), API keys (S3, Tavily), or public access (RSS, web crawls).

Connect once, search forever - Automatic sync across all your tools via configurable polling schedules (30 seconds to hours). No manual uploads.

---

How Feeds Work

No manual uploads

Set up once, content syncs automatically

Configurable polling

Schedule policies from 30 seconds to hours between checks

OAuth handled

No token management, Graphlit handles auth refresh

Incremental updates

Only new/changed content syncs (not full re-ingest)

Deduplication

Same file in Slack and Drive = one copy in your knowledge base

Listing modes (Past vs New)

Many feeds support Past vs New listing modes:

• Past: backfill existing items, then continue polling for new items

• New: only ingest items created after the feed is created

Some sources use specialized listing enums (e.g., EmailListingTypes, CalendarListingTypes) or date filters.

Sync mode (Archive vs Mirror)

Feeds support an optional syncMode:

• ARCHIVE: preserve ingested content even if the source deletes it

• MIRROR: synchronize with the source, including deletions

---

All Feeds

Cloud Storage

Amazon S3

Files from any S3 bucket Access Key auth • Automatic sync

Azure Blob Storage

Files from Azure containers Connection String auth • Automatic sync

Azure File Share

Files from Azure file shares Connection String auth • Automatic sync

Google Cloud Storage

Files from GCS buckets Service Account auth • Automatic sync

Use cases: Data lakes, backup archives, media libraries, log files

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Company Data Lake",
  type: FeedTypes.Site,
  site: {
    type: FeedServiceTypes.S3Blob,
    s3: {
      accessKey: process.env.AWS_ACCESS_KEY,
      secretAccessKey: process.env.AWS_SECRET_KEY,
      bucketName: "company-datalake",
      prefix: "documents/"  // Optional: filter by prefix
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Company Data Lake",
    type=FeedTypes.SITE,
    site={
        "type": FeedServiceTypes.S3_BLOB,
        "s3": {
            "accessKey": os.getenv("AWS_ACCESS_KEY"),
            "secretAccessKey": os.getenv("AWS_SECRET_KEY"),
            "bucketName": "company-datalake",
            "prefix": "documents/"  # Optional: filter by prefix
        }
    }
)

---

User Storage & Productivity

Microsoft SharePoint

Files and pages from SharePoint sites OAuth (Microsoft) • Automatic sync

Microsoft OneDrive

Personal and business files OAuth (Microsoft) • Automatic sync

Google Drive

Files, Docs, Sheets, Slides OAuth (Google) • Automatic sync

Dropbox

All file types OAuth (Dropbox) • Automatic sync

Box

Enterprise file storage OAuth (Box) • Automatic sync

Use cases: Company knowledge base, shared documentation, team collaboration, project resources

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Engineering Docs",
  type: FeedTypes.Site,
  site: {
    type: FeedServiceTypes.GoogleDrive,
    googleDrive: {
      refreshToken: process.env.GOOGLE_REFRESH_TOKEN,
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET
      // folderId: "..."  // Optional: sync specific folder only
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Engineering Docs",
    type=FeedTypes.SITE,
    site={
        "type": FeedServiceTypes.GOOGLE_DRIVE,
        "googleDrive": {
            "refreshToken": os.getenv("GOOGLE_REFRESH_TOKEN"),
            "clientId": os.getenv("GOOGLE_CLIENT_ID"),
            "clientSecret": os.getenv("GOOGLE_CLIENT_SECRET")
            # "folderId": "..."  # Optional: sync specific folder only
        }
    }
)

---

Communication & Messaging

Slack

Messages, threads, files from channels OAuth (Bot Token) • Automatic sync

Microsoft Teams

Messages from team channels OAuth (Microsoft) • Automatic sync

Discord

Messages, threads, files from servers OAuth (Bot Token) • Automatic sync

Twitter/X

Posts, media, conversations OAuth (Twitter API) • Automatic sync

Use cases: Team conversations, decision history, customer discussions, product feedback

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Engineering Slack",
  type: FeedTypes.Slack,
  slack: {
    channel: "engineering",  // Channel name or ID
    token: process.env.SLACK_BOT_TOKEN,
    type: FeedListingTypes.Past,
    includeAttachments: true
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedListingTypes, FeedTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Engineering Slack",
    type=FeedTypes.SLACK,
    slack={
        "channel": "engineering",
        "token": os.getenv("SLACK_BOT_TOKEN"),
        "type": FeedListingTypes.PAST,
        "includeAttachments": True
    }
)

---

Email

Gmail

Emails, attachments, labels, threads OAuth (Google) • Automatic sync

Microsoft Outlook

Emails, attachments, folders OAuth (Microsoft) • Automatic sync

Use cases: Customer communications, sales outreach, support context, contract negotiations

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Sales Inbox",
  type: FeedTypes.Email,
  email: {
    type: FeedServiceTypes.GoogleEmail,
    google: {
      refreshToken: process.env.GOOGLE_REFRESH_TOKEN,
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
      query: "from:*@acmecorp.com"
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Sales Inbox",
    type=FeedTypes.EMAIL,
    email={
        "type": FeedServiceTypes.GOOGLE_EMAIL,
        "google": {
            "refreshToken": os.getenv("GOOGLE_REFRESH_TOKEN"),
            "clientId": os.getenv("GOOGLE_CLIENT_ID"),
            "clientSecret": os.getenv("GOOGLE_CLIENT_SECRET"),
            "query": "from:*@acmecorp.com"
        }
    }
)

---

Issue Tracking & Project Management

Linear

Issues, comments, projects, roadmaps OAuth (Linear API) • Automatic sync

Jira

Issues, comments, boards, sprints OAuth (Atlassian) • Automatic sync

GitHub Issues

Repository issues and comments OAuth (GitHub) • Automatic sync

GitHub Commits

Repository commits and code changes OAuth (GitHub) • Automatic sync

GitHub Pull Requests

Pull requests and code reviews OAuth (GitHub) • Automatic sync

Trello

Cards, boards, checklists OAuth (Trello API) • Automatic sync

Use cases: Product roadmaps, bug tracking, feature requests, sprint planning

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Product Backlog",
  type: FeedTypes.Issue,
  issue: {
    type: FeedServiceTypes.Linear,
    linear: {
      apiKey: process.env.LINEAR_API_KEY,
      includeComments: true,
      includeClosed: false
      // teamId: "..."  // Optional: sync specific team only
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Product Backlog",
    type=FeedTypes.ISSUE,
    issue={
        "type": FeedServiceTypes.LINEAR,
        "linear": {
            "apiKey": os.getenv("LINEAR_API_KEY"),
            "includeComments": True,
            "includeClosed": False
            # "teamId": "..."  # Optional: sync specific team only
        }
    }
)

---

Knowledge Bases & Documentation

Connector	Content Types	Auth Type	Sync Mode
Notion	Pages, Databases	OAuth (Notion API)	Automatic
Intercom Articles	Articles	OAuth (Intercom)	Automatic
Zendesk Articles	Articles	OAuth (Zendesk)	Automatic

Use cases:

• Internal wikis

• Product documentation

• Help center content

• Company policies

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Engineering Wiki",
  type: FeedTypes.Notion,
  notion: {
    apiKey: process.env.NOTION_API_KEY,
    includeSubpages: true
    // databaseId: "..."  // Optional: sync specific database only
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Engineering Wiki",
    type=FeedTypes.NOTION,
    notion={
        "apiKey": os.getenv("NOTION_API_KEY"),
        "includeSubpages": True
        # "databaseId": "..."  # Optional: sync specific database only
    }
)

---

Support & Ticketing

Connector	Content Types	Auth Type	Sync Mode
Intercom Tickets	Tickets, Conversations	OAuth (Intercom)	Automatic
Zendesk Tickets	Tickets, Conversations	OAuth (Zendesk)	Automatic

Use cases:

• Customer support history

• Common issues

• Product feedback

• Feature requests

---

Code Repositories

Connector	Content Types	Auth Type	Sync Mode
GitHub	Code Files, README	OAuth (GitHub PAT)	Automatic

Use cases:

• Code search

• Documentation in repos

• README indexing

• API references

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Codebase",
  type: FeedTypes.Site,
  site: {
    type: FeedServiceTypes.GitHub,
    github: {
      personalAccessToken: process.env.GITHUB_TOKEN,
      repositoryOwner: "acmecorp",
      repositoryName: "backend-api"
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Codebase",
    type=FeedTypes.SITE,
    site={
        "type": FeedServiceTypes.GIT_HUB,
        "github": {
            "personalAccessToken": os.getenv("GITHUB_TOKEN"),
            "repositoryOwner": "acmecorp",
            "repositoryName": "backend-api"
        }
    }
)

---

Web & Content

Connector	Content Types	Auth Type	Sync Mode
Web Pages	Pages, Files	None	On-demand / Scheduled
Web Search	Search Results	None	On-demand
RSS Feeds	Posts, Articles	None	Automatic
Podcast RSS	Audio, Transcripts	None	Automatic
YouTube	Audio (transcribed)	API Key (optional)	On-demand
Reddit	Posts, Comments	API Key (optional)	Automatic

Use cases:

• Competitive intelligence

• News monitoring

• Content aggregation

• Market research

Example:

TypeScript

import { Graphlit } from 'graphlit-client';
import { FeedTypes, SearchServiceTypes, TimedPolicyRecurrenceTypes } from 'graphlit-client/dist/generated/graphql-types';

const client = new Graphlit();

// RSS feed
const rssFeed = await client.createFeed({
  name: "Competitor Blog",
  type: FeedTypes.Rss,
  rss: {
    uri: "https://competitor.com/blog/rss"
  }
});

// Web search feed
const searchFeed = await client.createFeed({
  name: "AI News",
  type: FeedTypes.Search,
  search: {
    type: SearchServiceTypes.Tavily,
    text: "artificial intelligence semantic memory",
    readLimit: 10
  },
  schedulePolicy: {
    recurrenceType: TimedPolicyRecurrenceTypes.Repeat,
    repeatInterval: "PT1H"
  }
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, SearchServiceTypes, TimedPolicyRecurrenceTypes
from datetime import timedelta

graphlit = Graphlit()

# RSS feed
rss_feed = await graphlit.client.create_feed(
    name="Competitor Blog",
    type=FeedTypes.RSS,
    rss={
        "uri": "https://competitor.com/blog/rss"
    }
)

# Web search feed
search_feed = await graphlit.client.create_feed(
    name="AI News",
    type=FeedTypes.SEARCH,
    search={
        "type": SearchServiceTypes.TAVILY,
        "text": "artificial intelligence semantic memory",
        "readLimit": 10
    },
    schedulePolicy={
        "recurrenceType": TimedPolicyRecurrenceTypes.REPEAT,
        "repeatInterval": timedelta(hours=1)
    }
)

---

Calendars

Connector	Content Types	Auth Type	Sync Mode
Google Calendar	Events	OAuth (Google)	Automatic
Microsoft Calendar	Events	OAuth (Microsoft)	Automatic

Use cases:

• Meeting recording triggers

• Event-based workflows

• Schedule context

• Attendee tracking

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Team Calendar",
  type: FeedTypes.Calendar,
  calendar: {
    type: FeedServiceTypes.GoogleCalendar,
    google: {
      refreshToken: process.env.GOOGLE_REFRESH_TOKEN,
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET
      // calendarId: "primary"  // Optional: defaults to primary calendar
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Team Calendar",
    type=FeedTypes.CALENDAR,
    calendar={
        "type": FeedServiceTypes.GOOGLE_CALENDAR,
        "google": {
            "refreshToken": os.getenv("GOOGLE_REFRESH_TOKEN"),
            "clientId": os.getenv("GOOGLE_CLIENT_ID"),
            "clientSecret": os.getenv("GOOGLE_CLIENT_SECRET")
            # "calendarId": "primary"  # Optional: defaults to primary calendar
        }
    }
)

---

Meetings & Call Transcripts

Connector	Content Types	Auth Type	Sync Mode
Fireflies.ai	Meeting transcripts, summaries	API Key	Automatic
Fathom	Meeting transcripts, summaries	API Key	Automatic
Attio Meetings	Meeting transcripts	API Key	Automatic

Use cases: meeting intelligence, searchable call history, action items, follow-ups

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: 'Fireflies Transcripts',
  type: FeedTypes.Meeting,
  meeting: {
    type: FeedServiceTypes.Fireflies,
    fireflies: {
      apiKey: process.env.FIREFLIES_API_KEY
    }
  }
});

Python

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Fireflies Transcripts",
    type=FeedTypes.MEETING,
    meeting={
        "type": FeedServiceTypes.FIREFLIES,
        "fireflies": {
            "apiKey": os.getenv("FIREFLIES_API_KEY")
        }
    }
)

---

CRM & Contacts

Connector	Content Types	Auth Type	Sync Mode
Attio CRM	CRM objects	API Key	Automatic
Google Contacts	Contacts	OAuth (Google)	Automatic
Microsoft Contacts	Contacts	OAuth (Microsoft)	Automatic
Salesforce CRM	CRM objects	OAuth (Salesforce)	Automatic

Use cases: account context, contact enrichment, sales/support history, relationship intelligence

---

Research & Entity Discovery

Connector	Content Types	Auth Type	Sync Mode
Parallel Research	Research reports, source links	API Key	Automatic
Parallel Entity Discovery	Entity candidates + sources	API Key	Automatic

Use cases: competitive intel, market maps, account research, enrichment pipelines

Example:

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: 'Parallel Research',
  type: FeedTypes.Research,
  research: {
    type: FeedServiceTypes.Parallel,
    query: 'Who are the top competitors to Graphlit, and what are their differentiators?'
  }
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Parallel Research",
    type=FeedTypes.RESEARCH,
    research={
        "type": FeedServiceTypes.PARALLEL,
        "query": "Who are the top competitors to Graphlit, and what are their differentiators?"
    }
)

---

---

Feed Sync Modes

Real-Time Sync (ARCHIVE)

Default mode: Preserve everything, never delete

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Slack Archive",
  type: FeedTypes.Slack,
  slack: {
    // ... slack configuration
  },
  schedulePolicy: {
    recurrenceType: TimedPolicyRecurrenceTypes.Repeat,
    repeatInterval: "PT5M"  // Check every 5 minutes (ISO 8601 duration)
  }
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, TimedPolicyRecurrenceTypes
from datetime import timedelta

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Slack Archive",
    type=FeedTypes.SLACK,
    slack={
        # ... slack configuration
    },
    schedulePolicy={
        "recurrenceType": TimedPolicyRecurrenceTypes.REPEAT,
        "repeatInterval": timedelta(minutes=5)
    }
)

Behavior:

• New content added

• Updated content re-indexed

• Deleted content at source → preserved in Graphlit

• Use case: Compliance, audit logs, historical research

---

Mirror Sync (MIRROR)

Mirror mode: Keep in sync with source

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Google Drive Mirror",
  type: FeedTypes.Site,
  site: {
    // ... site configuration
  },
  syncMode: FeedSyncMode.Mirror  // Mirror mode
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedSyncMode

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Google Drive Mirror",
    type=FeedTypes.SITE,
    site={
        # ... site configuration
    },
    syncMode=FeedSyncMode.MIRROR
)

Behavior:

• New content added

• Updated content re-indexed

• Deleted content at source → deleted in Graphlit

• Use case: Live documentation, current state only

---

OAuth Setup

Graphlit Manages OAuth

You don't need to:

• ❌ Store refresh tokens securely

• ❌ Handle token expiration

• ❌ Implement refresh logic

• ❌ Manage webhook subscriptions

Graphlit handles:

• ✅ Token storage (encrypted)

• ✅ Automatic refresh

• ✅ Webhook management

• ✅ Error recovery

Setup Process

1. Get OAuth credentials from provider (e.g., Google Cloud Console, Microsoft Azure Portal)

2. Exchange for refresh token (one-time)

3. Pass to Graphlit when creating feed

4. Done - Graphlit manages tokens forever

See: OAuth Setup Guide for detailed instructions per provider.

---

Feed Filters

Filter by Query (Gmail, Slack, etc.)

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Customer Emails",
  type: FeedTypes.Email,
  email: {
    type: FeedServiceTypes.GoogleEmail,
    google: {
      query: "from:*@acmecorp.com OR to:*@acmecorp.com"
    }
  }
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Customer Emails",
    type=FeedTypes.EMAIL,
    email={
        "type": FeedServiceTypes.GOOGLE_EMAIL,
        "google": {
            "query": "from:*@acmecorp.com OR to:*@acmecorp.com"
        }
    }
)

Filter by Folder/Channel

TypeScript

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Sales Folder",
  type: FeedTypes.Site,
  site: {
    type: FeedServiceTypes.OneDrive,
    oneDrive: {
      // folderId: "..."  // Optional: sync specific folder only
    }
  }
});

Python

from graphlit import Graphlit
from graphlit_api import FeedTypes, FeedServiceTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Sales Folder",
    type=FeedTypes.SITE,
    site={
        "type": FeedServiceTypes.ONE_DRIVE,
        "oneDrive": {
            # "folderId": "..."  # Optional: sync specific folder only
        }
    }
)

Filter by Time (Query-Time)

TypeScript

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

const client = new Graphlit();

// Feeds generally don't support "oldest message" cutoffs; instead, ingest and then filter at query-time.
const response = await client.queryContents({
  types: [ContentTypes.Message],
  createdInLast: "PT2160H", // ~90 days
  searchType: SearchTypes.Hybrid,
});

Python

from graphlit import Graphlit
from graphlit_api.enums import ContentTypes, SearchTypes
from graphlit_api.input_types import ContentFilter

graphlit = Graphlit()

response = await graphlit.client.query_contents(
    filter=ContentFilter(
        types=[ContentTypes.MESSAGE],
        created_in_last="PT2160H",  # ~90 days
        search_type=SearchTypes.HYBRID,
    ),
)

---

Common Patterns

Pattern 1: Multi-Source Customer View

TypeScript

import { Graphlit } from 'graphlit-client';

const client = new Graphlit();

// Connect all customer touchpoints
const feeds = [];

// Email conversations
feeds.push(await client.createFeed({ /* Gmail config */ }));

// Slack mentions  
feeds.push(await client.createFeed({ /* Slack config */ }));

// Support tickets
feeds.push(await client.createFeed({ /* Zendesk config */ }));

// Meeting notes
feeds.push(await client.createFeed({ /* Google Drive config */ }));

// Now search across all sources
const response = await client.queryContents({
  search: "Acme Corp pricing concerns",
});
// ↑ One query → all customer interactions

Python

from graphlit import Graphlit

graphlit = Graphlit()

# Connect all customer touchpoints
feeds = []

# Email conversations
feeds.append(await graphlit.client.create_feed(...))  # Gmail

# Slack mentions
feeds.append(await graphlit.client.create_feed(...))  # Slack

# Support tickets
feeds.append(await graphlit.client.create_feed(...))  # Zendesk

# Meeting notes
feeds.append(await graphlit.client.create_feed(...))  # Google Drive

# Now search across all sources
response = await graphlit.client.query_contents(
    filter={
        "search": "Acme Corp pricing concerns"
    }
)
# ↑ One query → all customer interactions

---

Pattern 2: Developer Knowledge Base

TypeScript

import { Graphlit } from 'graphlit-client';

const client = new Graphlit();

// Connect engineering sources
const feeds = [
    // Code
    await client.createFeed({ /* GitHub backend-api */ }),
    await client.createFeed({ /* GitHub frontend-app */ }),
    
    // Discussions
    await client.createFeed({ /* Slack engineering */ }),
    await client.createFeed({ /* Slack architecture */ }),
    
    // Issues
    await client.createFeed({ /* Linear engineering-team */ }),
    
    // Docs
    await client.createFeed({ /* Notion engineering-wiki */ }),
    
    // Meetings
    await client.createFeed({ /* Google Drive meeting-notes */ })
];

// Agent has full engineering context

Python

from graphlit import Graphlit

graphlit = Graphlit()

# Connect engineering sources
feeds = [
    # Code
    create_github_feed("backend-api"),
    create_github_feed("frontend-app"),
    
    # Discussions
    create_slack_feed("engineering"),
    create_slack_feed("architecture"),
    
    # Issues
    create_linear_feed("engineering-team"),
    
    # Docs
    create_notion_feed("engineering-wiki"),
    
    # Meetings
    create_google_drive_feed("meeting-notes")
]

# Agent has full engineering context

---

Pattern 3: Compliance Archive

TypeScript

import { Graphlit } from 'graphlit-client';
import { FeedSyncMode } from 'graphlit-client/dist/generated/graphql-types';

const client = new Graphlit();

// Archive everything (never delete)
const feeds = [
    await client.createFeed({ syncMode: FeedSyncMode.Archive /* Gmail config */ }),
    await client.createFeed({ syncMode: FeedSyncMode.Archive /* Slack config */ }),
    await client.createFeed({ syncMode: FeedSyncMode.Archive /* Teams config */ })
];

// All communications preserved
// Searchable for compliance
// Audit trail maintained

Python

from graphlit import Graphlit
from graphlit_api import FeedSyncMode

graphlit = Graphlit()

# Archive everything (never delete)
feeds = [
    await graphlit.client.create_feed(syncMode=FeedSyncMode.ARCHIVE, ...),  # Gmail
    await graphlit.client.create_feed(syncMode=FeedSyncMode.ARCHIVE, ...),  # Slack
    await graphlit.client.create_feed(syncMode=FeedSyncMode.ARCHIVE, ...)   # Teams
]

# All communications preserved
# Searchable for compliance
# Audit trail maintained

---

Real-World Example: Zine

Zine uses 20+ Graphlit connectors:

Connected sources:

• Slack, Teams, Discord

• Gmail, Outlook

• Google Drive, OneDrive, Dropbox

• Notion, Linear, Jira

• GitHub Issues

• Google Calendar, Microsoft Calendar

• Meeting recordings (auto-attached to calendar events)

Result:

• One search across all tools

• AI agents with full company context

• Meeting intelligence

• Customer interaction history

• Developer knowledge base

All powered by Graphlit connectors.

---

Connector Roadmap

Coming soon (upon request):

• Confluence

• ServiceNow

• Azure Repos

• Azure Boards

Want a connector? Request it in Discord

---

Next Steps

• MCP Integration - Use connectors via MCP

• Platform Overview - See how connectors fit into the platform

---

Connect once. Search forever.