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

All Feeds (30+)

Cloud Storage (4)

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 (5)

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,
    google: {
      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,
        "google": {
            "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 (4)

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 { 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
    botToken: process.env.SLACK_BOT_TOKEN,
    includeThreads: true,
    includeFiles: true
  }
});

import os
from graphlit import Graphlit
from graphlit_api import FeedTypes

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Engineering Slack",
    type=FeedTypes.SLACK,
    slack={
        "channel": "engineering",
        "botToken": os.getenv("SLACK_BOT_TOKEN"),
        "includeThreads": True,
        "includeFiles": True
    }
)

Email (2)

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 (4)

Linear

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

Jira

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

GitHub Issues

Issues, comments, pull requests OAuth (GitHub PAT) • 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 (3)

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 (2)

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 (1)

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",
      branch: "main",
      includeReadme: true
    }
  }
});

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",
            "branch": "main",
            "includeReadme": True
        }
    }
)

Web & Content (6)

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 } 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: {
    query: "artificial intelligence semantic memory",
    maxResults: 10,
    refreshInterval: 3600
  }
});

from graphlit import Graphlit
from graphlit_api import FeedTypes

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={
        "query": "artificial intelligence semantic memory",
        "maxResults": 10,
        "refreshInterval": 3600
    }
)

Calendars (2)

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

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 (SYNC)

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.Sync  // 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.SYNC
)

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

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

const client = new Graphlit();

const feed = await client.createFeed({
  name: "Recent Slack",
  type: FeedTypes.Slack,
  slack: {
    channel: "engineering",
    oldestMessageTime: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000)  // 90 days ago
  }
});

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

graphlit = Graphlit()

feed = await graphlit.client.create_feed(
    name="Recent Slack",
    type=FeedTypes.SLACK,
    slack={
        "channel": "engineering",
        "oldestMessageTime": datetime.now() - timedelta(days=90)
    }
)

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({
  filter: {
    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
Salesforce
ServiceNow
Azure Repos
Zoom (meeting recordings)
Google Meet (meeting recordings)
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 4 days ago

Was this helpful?