We are excited to launch our MCP (Model Context Protocol) Server for Graphlit! It provides powerful new capabilities for content ingestion and retrieval to MCP clients like Claude Desktop, Goose, Cline, Cursor, and Windsurf.

The Graphlit MCP Server is open-source, and provides an interface between the Graphlit Platform API, and MCP clients.

It requires free signup for a Graphlit account, and the creation of a Graphlit project to store your knowledge base. You can then configure your MCP client with the Graphlit project credentials, and you're on your way.

By integrating the Graphlit Platform with MCP, we can now provide LLM-enabled, agentic workflows inside any MCP-compatible client.

Ingest anything from Slack to Gmail to podcast feeds, in addition to web crawling, into a Graphlit project - and then retrieve relevant contents from the MCP client.

Documents (PDF, DOCX, PPTX, etc.) and HTML web pages will be extracted to Markdown upon ingestion. Audio and video files will be transcribed upon ingestion.

MCP

(Credit: Anthropic MCP protocol)

MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.

Why MCP?

MCP helps you build agents and complex workflows on top of LLMs. LLMs frequently need to integrate with data and tools, and MCP provides:

• A growing list of pre-built integrations that your LLM can directly plug into

• The flexibility to switch between LLM providers and vendors

• Best practices for securing your data within your infrastructure

Overview

Our initial release of the Graphlit MCP Server supports:

Tools

Retrieval

• Retrieve Sources

• Visually Describe Images

Ingestion

• Files

• Web Pages

• Text

Data Connectors

• Microsoft Outlook email

• Google Mail

• Notion

• Reddit

• Linear

• Jira

• GitHub Issues

• Google Drive

• OneDrive

• SharePoint

• Dropbox

• Box

• GitHub

• Slack

• Microsoft Teams

• Discord

• Podcasts (RSS)

Web

• Web Crawling

• Web Search

• Web Mapping

• Screenshot Page

Operations

• Create Collection

• Add Contents to Collection

• Remove Contents from Collection

• Delete Collection

• Delete Feed

• Delete Content

• Is Feed Done?

• Is Content Done?

Enumerations

• List Slack Channels

• List Microsoft Teams Teams

• List Microsoft Teams Channels

• List SharePoint Libraries

• List SharePoint Folders

• List Linear Projects

Resources

• Contents

• Feeds

• Collections (of Content)

Configuration

To use the Graphlit MCP Server in an MCP client, you will need to configure Graphlit as an MCP server.

You can find the organization ID, environment ID, and JWT secret in your Graphlit project.

For example, in the Claude Desktop application, you will need to add the 'graphlit-mcp-server' entry to the configuration file.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

{
    "mcpServers": {
        "graphlit-mcp-server": {
            "command": "npx",
            "args": [
                "-y",
                "graphlit-mcp-server"
            ],
            "env": {
                "GRAPHLIT_ORGANIZATION_ID": "your-organization-id",
                "GRAPHLIT_ENVIRONMENT_ID": "your-environment-id",
                "GRAPHLIT_JWT_SECRET": "your-jwt-secret",
            }
        }
    }
}

Optionally, you can configure the credentials for data connectors, such as Slack, Google Email and Notion.

{
    "mcpServers": {
        "graphlit-mcp-server": {
            "command": "npx",
            "args": [
                "-y",
                "graphlit-mcp-server"
            ],
            "env": {
                "GRAPHLIT_ORGANIZATION_ID": "your-organization-id",
                "GRAPHLIT_ENVIRONMENT_ID": "your-environment-id",
                "GRAPHLIT_JWT_SECRET": "your-jwt-secret",
                "SLACK_BOT_TOKEN": "your-slack-bot-token",
                "DISCORD_BOT_TOKEN": "your-discord-bot-token",
                "GOOGLE_EMAIL_REFRESH_TOKEN": "your-google-refresh-token",
                "GOOGLE_EMAIL_CLIENT_ID": "your-google-client-id",
                "GOOGLE_EMAIL_CLIENT_SECRET": "your-google-client-secret",
                "LINEAR_API_KEY": "your-linear-api-key",
                "GITHUB_PERSONAL_ACCESS_TOKEN": "your-github-pat",
                "JIRA_EMAIL": "your-jira-email",
                "JIRA_TOKEN": "your-jira-token",
                "NOTION_API_KEY": "your-notion-api-key",
                "NOTION_DATABASE_ID": "your-notion-database-id"
            }
        }
    }
}

Alternately, you can install the Graphlit MCP Server via Smithery:

npx -y @smithery/cli install @graphlit/graphlit-mcp-server --client claude

Configuring Goose CLI

In the examples below, we'll use the Goose CLI, from Block.

You can add the Graphlit MCP server as an extension.

At minimum, you'll want to configure your GRAPHLIT_ORGANIZATION_ID, GRAPHLIT_ENVIRONMENT_ID, and GRAPHLIT_JWT_SECRET environment variables.

You can also assign the credentials for Slack, Google Drive, etc.

Use Cases

Ingest Email

By asking Goose to help us ingest our Google email, and asking it to preview the steps first, it walks us through ingestion step by step.

We have configured our Google client ID, client secret and refresh token in the Goose MCP client, so the Graphlit MCP Server doesn't need to ask for authentication.

Goose is smart enough to see there's a tool called 'isFeedDone' to poll on the completion of feed ingestion.

Summarize Email

Now that we've ingested our email, let's find any invoices which need to be paid.

We can ask for a summary report to send to our finance team.

First, Goose uses the 'retrieveSources' tool to retrieve relevant contents from the Graphlit project.

You can see that Goose is aware that 'contents' are exposed as MCP resources, and it retrieves each content item.

Now that it has the relevant emails, it summarizes recently paid invoices and those which require payment.

It saves that report by calling the 'ingestText' tool to create a new piece of (searchable) content.

Web Crawling

Summarize Web Documentation

Now that we have ingested our web documentation into Graphlit, and now want to summarize the main bullet points from each page.

Goose uses the 'content' MCP resource to pull the Markdown text from each page, and then summarizes the results into bullet points.

Web Research

You can automate web research with Graphlit, by web searching, ingesting the web pages, and then creating collections of content to be summarized.

Podcast Research

Graphlit supports audio ingestion, such as podcasts, and can be used to analyze the transcripts of ingested podcasts.

Here we're searching for an RSS feed URL, which first uses the 'webSearch' tool.

Once Goose locates the RSS URL, it calls 'ingestRSS' to ingest the most recent episode of the podcast, which is automatically transcribed for us.

Goose polls for the completion of the data feed with the 'isFeedDone' tool.

Once the podcast episode has been ingested, we can ask Goose to pull some relevant quotes from the transcript.

Here, we're asking for fun quotes between the hosts Piper and JT Brown.

Goose uses the 'retrieveSources' tool to retrieve ranked sources, via vector search.

Manage Data Feeds

You can also manage the ingested contents and data feeds through MCP.

Here we can ask Goose for the existing data feeds, and then ask it to delete each one.

Please let us know what tools or resources you would like to see in the Graphlit MCP Server.

Support

For support with the Graphlit MCP Server, please submit a GitHub Issue.

For further support with the Graphlit Platform, please join our Discord community.