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:

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
    }
  }
});

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:

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
    }
  }
});

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:

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
  }
});

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:

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"
    }
  }
});

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:

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
    }
  }
});

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:

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
  }
});

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:

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"
    }
  }
});

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:

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"
  }
});

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:

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
    }
  }
});

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:

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
    }
  }
});

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:

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?'
  }
});

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

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)
  }
});

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

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
});

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

Get OAuth credentials from provider (e.g., Google Cloud Console, Microsoft Azure Portal)
Exchange for refresh token (one-time)
Pass to Graphlit when creating feed
Done - Graphlit manages tokens forever

See: OAuth Setup Guide for detailed instructions per provider.

Feed Filters

Filter by Query (Gmail, Slack, etc.)

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"
    }
  }
});

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

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
    }
  }
});

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)

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,
});

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

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

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

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

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

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

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.

Last updated 16 days ago

hashtagHow Feeds Work

hashtagListing modes (Past vs New)

hashtagSync mode (Archive vs Mirror)

hashtagAll Feeds

hashtagCloud Storage

hashtagUser Storage & Productivity

hashtagCommunication & Messaging

hashtagEmail

hashtagIssue Tracking & Project Management

hashtagKnowledge Bases & Documentation

hashtagSupport & Ticketing

hashtagCode Repositories

hashtagWeb & Content

hashtagCalendars

hashtagMeetings & Call Transcripts

hashtagCRM & Contacts

hashtagResearch & Entity Discovery

hashtagFeed Sync Modes

hashtagReal-Time Sync (ARCHIVE)

hashtagMirror Sync (MIRROR)

hashtagOAuth Setup

hashtagGraphlit Manages OAuth

hashtagSetup Process

hashtagFeed Filters

hashtagFilter by Query (Gmail, Slack, etc.)

hashtagFilter by Folder/Channel

hashtagFilter by Time (Query-Time)

hashtagCommon Patterns

hashtagPattern 1: Multi-Source Customer View

hashtagPattern 2: Developer Knowledge Base

hashtagPattern 3: Compliance Archive

hashtagReal-World Example: Zine

hashtagConnector Roadmap

hashtagNext Steps

How Feeds Work

Listing modes (Past vs New)

Sync mode (Archive vs Mirror)

All Feeds

Cloud Storage

User Storage & Productivity

Communication & Messaging

Email

Issue Tracking & Project Management

Knowledge Bases & Documentation

Support & Ticketing

Code Repositories

Web & Content

Calendars

Meetings & Call Transcripts

CRM & Contacts

Research & Entity Discovery

Feed Sync Modes

Real-Time Sync (ARCHIVE)

Mirror Sync (MIRROR)

OAuth Setup

Graphlit Manages OAuth

Setup Process

Feed Filters

Filter by Query (Gmail, Slack, etc.)

Filter by Folder/Channel

Filter by Time (Query-Time)

Common Patterns

Pattern 1: Multi-Source Customer View

Pattern 2: Developer Knowledge Base

Pattern 3: Compliance Archive

Real-World Example: Zine

Connector Roadmap

Next Steps