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.

Set up once, content syncs automatically

Schedule policies from 30 seconds to hours between checks

No token management, Graphlit handles auth refresh

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

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

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:

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:

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:

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:

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:

Knowledge Bases & Documentation

Use cases:

Example:

Use cases:

Example:

Use cases:

Example:

Use cases:

Meeting recording triggers

Example:

Meetings & Call Transcripts

Meeting transcripts, summaries

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

Example:

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

Research & Entity Discovery

Research reports, source links

Parallel Entity Discovery

Entity candidates + sources

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

Example:

Default mode: Preserve everything, never delete

Behavior:

Updated content re-indexed
Deleted content at source → preserved in Graphlit
Use case: Compliance, audit logs, historical research

Mirror mode: Keep in sync with source

Behavior:

Updated content re-indexed
Deleted content at source → deleted in Graphlit
Use case: Live documentation, current state only

You don't need to:

❌ Store refresh tokens securely
❌ Handle token expiration
❌ Implement refresh logic
❌ Manage webhook subscriptions

Graphlit handles:

✅ Token storage (encrypted)

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.

Filter by Query (Gmail, Slack, etc.)

Filter by Time (Query-Time)

Pattern 1: Multi-Source Customer View

Pattern 2: Developer Knowledge Base

Pattern 3: Compliance Archive

Zine uses 20+ Graphlit connectors:

Connected sources:

Google Drive, OneDrive, Dropbox
Google Calendar, Microsoft Calendar
Meeting recordings (auto-attached to calendar events)

Result:

One search across all tools
AI agents with full company context
Customer interaction history

All powered by Graphlit connectors.

Coming soon (upon request):

Want a connector? Request it in Discord

Connect once. Search forever.

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

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

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

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

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

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

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

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

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

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

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

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

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
)

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

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

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

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

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

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