Graphlit logo

Graphlit

Organization
graphlit

Model Context Protocol (MCP) Server for Graphlit Platform

Publishergraphlit
Repositorygraphlit-mcp-server
LanguageTypeScript
Forks
55
Stars
381
Available tools
64
Transport typestdio
Categories
LicenseMIT
Links
  • Connect tools to AI workflows

    Graphlit exposes MCP capabilities that can be used by compatible AI clients and agents.

  • 64 available tools

    Browse the callable actions below, including names and descriptions when provided by the server.

  • Ready-to-copy setup

    Use the installation snippets to configure this server in your preferred MCP client.

  • Open source signals

    381 stars and 55 forks from the linked repository.

npm version smithery badge

Model Context Protocol (MCP) Server for Graphlit Platform

Overview

The Model Context Protocol (MCP) Server enables integration between MCP clients and the Graphlit service. This document outlines the setup process and provides a basic example of using the client.

Ingest anything from Slack, Discord, websites, Google Drive, email, Jira, Linear or GitHub into a Graphlit project - and then search and retrieve relevant knowledge within an MCP client like Cursor, Windsurf, Goose or Cline.

Your Graphlit project acts as a searchable, and RAG-ready knowledge base across all your developer and product management tools.

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.

Web crawling and web search are built-in as MCP tools, with no need to integrate other tools like Firecrawl, Exa, etc. separately.

You can read more about the MCP Server use cases and features on our blog.

Watch our latest YouTube video on using the Graphlit MCP Server with the Goose MCP client.

For any questions on using the MCP Server, please join our Discord community and post on the #mcp channel.

Tools

Retrieval

  • Query Contents
  • Query Collections
  • Query Feeds
  • Query Conversations
  • Retrieve Relevant Sources
  • Retrieve Similar Images
  • Visually Describe Image

RAG

  • Prompt LLM Conversation

Extraction

  • Extract Structured JSON from Text

Publishing

  • Publish as Audio (ElevenLabs Audio)
  • Publish as Image (OpenAI Image Generation)

Ingestion

  • Files
  • Web Pages
  • Messages
  • Posts
  • Emails
  • Issues
  • Text
  • Memory (Short-Term)

Data Connectors

  • Microsoft Outlook email
  • Google Mail
  • Notion
  • Reddit
  • Linear
  • Jira
  • GitHub Issues
  • Google Drive
  • OneDrive
  • SharePoint
  • Dropbox
  • Box
  • GitHub
  • Slack
  • Microsoft Teams
  • Discord
  • Twitter/X
  • Podcasts (RSS)

Web

  • Web Crawling
  • Web Search (including Podcast Search)
  • Web Mapping
  • Screenshot Page

Notifications

  • Slack
  • Email
  • Webhook
  • Twitter/X

Operations

  • Configure Project
  • Create Collection
  • Add Contents to Collection
  • Remove Contents from Collection
  • Delete Collection(s)
  • Delete Feed(s)
  • Delete Content(s)
  • Delete Conversation(s)
  • 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
  • List Notion Databases
  • List Notion Pages
  • List Dropbox Folders
  • List Box Folders
  • List Discord Guilds
  • List Discord Channels
  • List Google Calendars
  • List Microsoft Calendars

Resources

  • Project
  • Contents
  • Feeds
  • Collections (of Content)
  • Workflows
  • Conversations
  • Specifications

Prerequisites

Before you begin, ensure you have the following:

  • Node.js installed on your system (recommended version 18.x or higher).
  • An active account on the Graphlit Platform with access to the API settings dashboard.

Configuration

The Graphlit MCP Server supports environment variables to be set for authentication and configuration:

  • GRAPHLIT_ENVIRONMENT_ID: Your environment ID.
  • GRAPHLIT_ORGANIZATION_ID: Your organization ID.
  • GRAPHLIT_JWT_SECRET: Your JWT secret for signing the JWT token.

You can find these values in the API settings dashboard on the Graphlit Platform.

Installation

Installing via VS Code

For quick installation, use one of the one-click install buttons below:

Install with NPX in VS Code Install with NPX in VS Code Insiders

For manual installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing Ctrl + Shift + P and typing Preferences: Open User Settings (JSON).

Optionally, you can add it to a file called .vscode/mcp.json in your workspace. This will allow you to share the configuration with others.

Note that the mcp key is not needed in the .vscode/mcp.json file.

json
{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "organization_id",
        "description": "Graphlit Organization ID",
        "password": true
      },
      {
        "type": "promptString",
        "id": "environment_id",
        "description": "Graphlit Environment ID",
        "password": true
      },
      {
        "type": "promptString",
        "id": "jwt_secret",
        "description": "Graphlit JWT Secret",
        "password": true
      }
    ],
    "servers": {
      "graphlit": {
        "command": "npx",
        "args": ["-y", "graphlit-mcp-server"],
        "env": {
          "GRAPHLIT_ORGANIZATION_ID": "${input:organization_id}",
          "GRAPHLIT_ENVIRONMENT_ID": "${input:environment_id}",
          "GRAPHLIT_JWT_SECRET": "${input:jwt_secret}"
        }
      }
    }
  }
}

Installing via Windsurf

To install graphlit-mcp-server in Windsurf IDE application, Cline should use NPX:

bash
npx -y graphlit-mcp-server

Your mcp_config.json file should be configured similar to:

{
    "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",
            }
        }
    }
}

Installing via Cline

To install graphlit-mcp-server in Cline IDE application, Cline should use NPX:

bash
npx -y graphlit-mcp-server

Your cline_mcp_settings.json file should be configured similar to:

{
    "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",
            }
        }
    }
}

Installing via Cursor

To install graphlit-mcp-server in Cursor IDE application, Cursor should use NPX:

bash
npx -y graphlit-mcp-server

Your mcp.json file should be configured similar to:

{
    "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",
            }
        }
    }
}

Installing via Smithery

To install graphlit-mcp-server for Claude Desktop automatically via Smithery:

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

Installing manually

To use the Graphlit MCP Server in any MCP client application, use:

{
    "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. Only GRAPHLIT_ORGANIZATION_ID, GRAPHLIT_ENVIRONMENT_ID and GRAPHLIT_JWT_SECRET are required.

{
    "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",
                "TWITTER_TOKEN": "your-twitter-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"
            }
        }
    }
}

NOTE: when running 'npx' on Windows, you may need to explicitly call npx via the command prompt.

"command": "C:\\Windows\\System32\\cmd.exe /c npx"

Support

Please refer to the Graphlit API Documentation.

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

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

Installation

TypingMind
Prerequisites:

Node.js 18+

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

Available Tools

  • configureProject

    Configures the default content workflow and conversation specification for the Graphlit project. Only needed if user asks to configure the project defaults. Do not call unless specifically asked for by the user. To reset the project configuration to 'factory state', assign False or null to all parameters. Optionally accepts whether to configure the default specification for LLM conversations. Defaults to using OpenAI GPT-4o, if not assigned. Optionally accepts whether to enable high-quality document and web page preparation using a vision LLM. Defaults to using Azure AI Document Intelligence for document preparation, if not assigned. Optionally accepts whether to enable entity extraction using LLM into the knowledge graph. Defaults to no entity extraction, if not assigned. Optionally accepts the preferred model provider service type, i.e. Anthropic, OpenAI, Google. Defaults to Anthropic if not provided. Returns the project identifier.

  • queryProjectUsage

    Queries project usage records. Usage record name describes the operation, i.e. 'Prompt completion', 'Text embedding', 'GraphQL', 'Entity Event'. 'GraphQL' usage records are used for GraphQL operations, i.e. 'queryContents', 'retrieveSources', 'askGraphlit', etc. 'Entity Event' usage records are used for async compute operations. 'Text embedding' usage records are used for text embedding operations. 'Prompt completion' usage records are used for LLM prompt completion operations, i.e. when using 'promptConversation'. 'Data extraction' usage records are used for data extraction operations, using LLMs to extract knowledge graph entities. Look at 'metric' field for the type of metric captured in the usage record, i.e. BYTES, TOKENS, UNITS, REQUESTS. Look for 'credits' field which describes how many credits were charged by the operation. Look for 'promptTokens', 'completionTokens' and (total) 'tokens' fields which describe the number of tokens used by the

  • askGraphlit

    Ask questions about using the Graphlit Platform, or specifically about the Graphlit API or SDKs. When the user asks about how to use the Graphlit API or SDKs, use this tool to provide a code sample in Python, TypeScript or C#. Accepts an LLM user prompt. Returns the LLM prompt completion in Markdown format.

  • promptConversation

    Prompts an LLM conversation about your entire Graphlit knowledge base. Uses hybrid vector search based on user prompt for locating relevant content sources. Uses LLM to complete the user prompt with the configured LLM. Maintains conversation history between 'user' and LLM 'assistant'. Prefer 'promptConversation' when the user intends to start or continue an ongoing conversation about the entire Graphlit knowledge base. Similar to 'retrieveSources' but does not perform content metadata filtering. Accepts an LLM user prompt and optional conversation identifier. Will either create a new conversation or continue an existing one. Will use the default specification for LLM conversations, which is optionally configured with the 'configureProject' tool. Returns the conversation identifier, completed LLM message, and any citations from the LLM response.

  • retrieveSources

    Retrieve relevant content sources from Graphlit knowledge base. Do not use for retrieving content by content identifier - retrieve content resource instead, with URI 'contents://{id}'. Accepts an LLM user prompt for content retrieval. For best retrieval quality, provide only key words or phrases from the user prompt, which will be used to create text embeddings for a vector search query. Only use when there is a valid LLM user prompt for content retrieval, otherwise use 'queryContents'. For example 'recent content' is not a useful user prompt, since it doesn't reference the text in the content. Only use for 'one shot' retrieval of content sources, i.e. when the user is not interested in having a conversation about the content. Accepts an optional ingestion recency filter (defaults to null, meaning all time), and optional content type and file type filters. Also accepts optional feed and collection identifiers to filter content by. Returns the ranked content so

  • retrieveImages

    Retrieve images from Graphlit knowledge base. Provides image-specific retrieval when image similarity search is desired. Do not use for retrieving content by content identifier - retrieve content resource instead, with URI 'contents://{id}'. Accepts image URL. Image will be used for similarity search using image embeddings. Accepts optional geo-location filter for search by latitude, longitude and optional distance radius. Images taken with GPS enabled are searchable by geo-location. Also accepts optional recency filter (defaults to null, meaning all time), and optional feed and collection identifiers to filter images by. Returns the matching images, including their content resource URI to retrieve the complete Markdown text.

  • extractText

    Extracts JSON data from text using LLM. Accepts text to be extracted, and JSON schema which describes the data which will be extracted. JSON schema needs be of type 'object' and include 'properties' and 'required' fields. Optionally accepts text prompt which is provided to LLM to guide data extraction. Defaults to 'Extract data using the tools provided'. Returns extracted JSON from text.

  • createCollection

    Create a collection. Accepts a collection name, and optional list of content identifiers to add to collection. Returns the collection identifier

  • addContentsToCollection

    Add contents to a collection. Accepts a collection identifier and a list of content identifiers to add to collection. Returns the collection identifier.

  • removeContentsFromCollection

    Remove contents from collection. Accepts a collection identifier and a list of content identifiers to remove from collection. Returns the collection identifier.

  • deleteContent

    Deletes content from Graphlit knowledge base. Accepts content identifier. Returns the content identifier and content state, i.e. Deleted.

  • deleteConversation

    Deletes conversation from Graphlit knowledge base. Accepts conversation identifier. Returns the conversation identifier and content state, i.e. Deleted.

  • deleteCollection

    Deletes collection from Graphlit knowledge base. Does not delete the contents in the collection, only the collection itself. Accepts collection identifier. Returns the collection identifier and collection state, i.e. Deleted.

  • deleteFeed

    Deletes feed from Graphlit knowledge base. Does delete the contents in the feed, in addition to the feed itself. Accepts feed identifier. Returns the feed identifier and feed state, i.e. Deleted.

  • deleteFeeds

    Deletes feeds from Graphlit knowledge base. Does delete the contents in the feed, in addition to the feed itself. Accepts optional feed type filter to limit the feeds which will be deleted. Also accepts optional limit of how many feeds to delete, defaults to 100. Returns the feed identifiers and feed state, i.e. Deleted.

  • deleteCollections

    Deletes collections from Graphlit knowledge base. Does not delete the contents in the collections, only the collections themselves. Accepts optional limit of how many collections to delete, defaults to 100. Returns the collection identifiers and collection state, i.e. Deleted.

  • deleteConversations

    Deletes conversations from Graphlit knowledge base. Accepts optional limit of how many conversations to delete, defaults to 100. Returns the conversation identifiers and conversation state, i.e. Deleted.

  • deleteContents

    Deletes contents from Graphlit knowledge base. Accepts optional content type and file type filters to limit the contents which will be deleted. Also accepts optional limit of how many contents to delete, defaults to 1000. Returns the content identifiers and content state, i.e. Deleted.

  • queryContents

    Query contents from Graphlit knowledge base. Do not use for retrieving content by content identifier - retrieve content resource instead, with URI 'contents://{id}'. Accepts optional content name, content type and file type for metadata filtering. Accepts optional hybrid vector search query. Accepts optional recency filter (defaults to null, meaning all time), and optional feed and collection identifiers to filter images by. Accepts optional geo-location filter for search by latitude, longitude and optional distance radius. Images and videos taken with GPS enabled are searchable by geo-location. Returns the matching contents, including their content resource URI to retrieve the complete Markdown text.

  • queryCollections

    Query collections from Graphlit knowledge base. Do not use for retrieving collection by collection identifier - retrieve collection resource instead, with URI 'collections://{id}'. Accepts optional collection name for metadata filtering. Returns the matching collections, including their collection resource URI to retrieve the collection contents.

  • queryFeeds

    Query feeds from Graphlit knowledge base. Do not use for retrieving feed by feed identifier - retrieve feed resource instead, with URI 'feeds://{id}'. Accepts optional feed name and feed type for metadata filtering. Returns the matching feeds, including their feed resource URI to retrieve the feed contents.

  • queryConversations

    Query conversations from Graphlit knowledge base. Do not use for retrieving conversation by conversation identifier - retrieve conversation resource instead, with URI 'conversations://{id}'. Accepts optional hybrid vector search query. Accepts optional recency filter (defaults to null, meaning all time). Returns the matching conversations, including their conversation resource URI to retrieve the complete conversation message history.

  • isContentDone

    Check if content has completed asynchronous ingestion. Accepts a content identifier which was returned from one of the non-feed ingestion tools, like ingestUrl. Returns whether the content is done or not.

  • isFeedDone

    Check if an asynchronous feed has completed ingesting all the available content. Accepts a feed identifier which was returned from one of the ingestion tools, like ingestGoogleDriveFiles. Returns whether the feed is done or not.

  • listNotionDatabases

    Lists available Notion databases. Requires environment variable to be configured: NOTION_API_KEY. Returns a list of Notion databases, where the database identifier can be used with ingestNotionPages to ingest pages into Graphlit knowledge base.

  • listLinearProjects

    Lists available Linear projects. Requires environment variable to be configured: LINEAR_API_KEY. Returns a list of Linear projects, where the project name can be used with ingestLinearIssues to ingest issues into Graphlit knowledge base.

  • listSlackChannels

    Lists available Slack channels. Requires environment variable to be configured: SLACK_BOT_TOKEN. Returns a list of Slack channels, where the channel name can be used with ingestSlackMessages to ingest messages into Graphlit knowledge base.

  • listSharePointLibraries

    Lists available SharePoint libraries. Requires environment variables to be configured: SHAREPOINT_CLIENT_ID, SHAREPOINT_CLIENT_SECRET, SHAREPOINT_REFRESH_TOKEN. Returns a list of SharePoint libraries, where the selected libraryId can be used with listSharePointFolders to enumerate SharePoint folders in a library.

  • listSharePointFolders

    Lists available SharePoint folders. Requires environment variables to be configured: SHAREPOINT_CLIENT_ID, SHAREPOINT_CLIENT_SECRET, SHAREPOINT_REFRESH_TOKEN. Returns a list of SharePoint folders, which can be used with ingestSharePointFiles to ingest files into Graphlit knowledge base.

  • ingestSharePointFiles

    Ingests files from SharePoint library into Graphlit knowledge base. Accepts a SharePoint libraryId and an optional folderId to ingest files from a specific SharePoint folder. Libraries can be enumerated with listSharePointLibraries and library folders with listSharePointFolders. Requires environment variables to be configured: SHAREPOINT_ACCOUNT_NAME, SHAREPOINT_CLIENT_ID, SHAREPOINT_CLIENT_SECRET, SHAREPOINT_REFRESH_TOKEN. Accepts an optional read limit for the number of files to ingest. Executes asynchronously, creates SharePoint feed, and returns the feed identifier.

  • ingestOneDriveFiles

    Ingests files from OneDrive into Graphlit knowledge base. Accepts optional OneDrive folder identifier, and an optional read limit for the number of files to ingest. If no folder identifier provided, ingests files from root OneDrive folder. Requires environment variables to be configured: ONEDRIVE_CLIENT_ID, ONEDRIVE_CLIENT_SECRET, ONEDRIVE_REFRESH_TOKEN. Executes asynchronously, creates OneDrive feed, and returns the feed identifier.

  • ingestGoogleDriveFiles

    Ingests files from Google Drive into Graphlit knowledge base. Accepts optional Google Drive folder identifier, and an optional read limit for the number of files to ingest. For example, with Google Drive URI (https://drive.google.com/drive/u/0/folders/32tzhRD12KDh2hXABY8OZRFv7Smy8WBkQ), the folder identifier is 32tzhRD12KDh2hXABY8OZRFv7Smy8WBkQ. If no folder identifier provided, ingests files from root Google Drive folder. Requires environment variables to be configured: GOOGLE_DRIVE_SERVICE_ACCOUNT_JSON -or- GOOGLE_DRIVE_CLIENT_ID, GOOGLE_DRIVE_CLIENT_SECRET, GOOGLE_DRIVE_REFRESH_TOKEN. If service account JSON is provided, uses service account authentication. Else, uses user authentication. Executes asynchronously, creates Google Drive feed, and returns the feed identifier.

  • ingestDropboxFiles

    Ingests files from Dropbox into Graphlit knowledge base. Accepts optional relative path to Dropbox folder (i.e. /Pictures), and an optional read limit for the number of files to ingest. If no path provided, ingests files from root Dropbox folder. Requires environment variables to be configured: DROPBOX_APP_KEY, DROPBOX_APP_SECRET, DROPBOX_REDIRECT_URI, DROPBOX_REFRESH_TOKEN. Executes asynchronously, creates Dropbox feed, and returns the feed identifier.

  • ingestBoxFiles

    Ingests files from Box into Graphlit knowledge base. Accepts optional Box folder identifier, and an optional read limit for the number of files to ingest. If no folder identifier provided, ingests files from root Box folder (i.e. "0"). Folder identifier can be inferred from Box URL. https://app.box.com/folder/123456 -> folder identifier is "123456". Requires environment variables to be configured: BOX_CLIENT_ID, BOX_CLIENT_SECRET, BOX_REDIRECT_URI, BOX_REFRESH_TOKEN. Executes asynchronously, creates Box feed, and returns the feed identifier.

  • ingestGitHubFiles

    Ingests files from GitHub repository into Graphlit knowledge base. Accepts GitHub repository owner and repository name and an optional read limit for the number of files to ingest. For example, for GitHub repository (https://github.com/openai/tiktoken), 'openai' is the repository owner, and 'tiktoken' is the repository name. Requires environment variable to be configured: GITHUB_PERSONAL_ACCESS_TOKEN. Executes asynchronously, creates GitHub feed, and returns the feed identifier.

  • ingestNotionPages

    Ingests pages from Notion database into Graphlit knowledge base. Accepts Notion database identifier and an optional read limit for the number of pages to ingest. You can list the available Notion database identifiers with listNotionDatabases. Or, for a Notion URL, https://www.notion.so/Example/Engineering-Wiki-114abc10cb38487e91ec906fc6c6f350, 'Engineering-Wiki-114abc10cb38487e91ec906fc6c6f350' is an example of a Notion database identifier. Requires environment variable to be configured: NOTION_API_KEY. Executes asynchronously, creates Notion feed, and returns the feed identifier.

  • ingestMicrosoftTeamsMessages

    Ingests messages from Microsoft Teams channel into Graphlit knowledge base. Accepts Microsoft Teams team identifier and channel identifier, and an optional read limit for the number of messages to ingest. Requires environment variables to be configured: MICROSOFT_TEAMS_CLIENT_ID, MICROSOFT_TEAMS_CLIENT_SECRET, MICROSOFT_TEAMS_REFRESH_TOKEN. Executes asynchronously, creates Microsoft Teams feed, and returns the feed identifier.

  • ingestSlackMessages

    Ingests messages from Slack channel into Graphlit knowledge base. Accepts Slack channel name and an optional read limit for the number of messages to ingest. Requires environment variable to be configured: SLACK_BOT_TOKEN. Executes asynchronously, creates Slack feed, and returns the feed identifier.

  • ingestDiscordMessages

    Ingests messages from Discord channel into Graphlit knowledge base. Accepts Discord channel name and an optional read limit for the number of messages to ingest. Requires environment variable to be configured: DISCORD_BOT_TOKEN. Executes asynchronously, creates Discord feed, and returns the feed identifier.

  • ingestTwitterPosts

    Ingests posts by user from Twitter/X into Graphlit knowledge base. Accepts Twitter/X user name, without the leading @ symbol, and an optional read limit for the number of posts to ingest. Requires environment variable to be configured: TWITTER_TOKEN. Executes asynchronously, creates Twitter feed, and returns the feed identifier.

  • ingestTwitterSearch

    Searches for recent posts from Twitter/X, and ingests them into Graphlit knowledge base. Accepts search query, and an optional read limit for the number of posts to ingest. Requires environment variable to be configured: TWITTER_TOKEN. Executes asynchronously, creates Twitter feed, and returns the feed identifier.

  • ingestRedditPosts

    Ingests posts from Reddit subreddit into Graphlit knowledge base. Accepts a subreddit name and an optional read limit for the number of posts to ingest. Executes asynchronously, creates Reddit feed, and returns the feed identifier.

  • ingestGoogleEmail

    Ingests emails from Google Email account into Graphlit knowledge base. Accepts an optional read limit for the number of emails to ingest. Requires environment variables to be configured: GOOGLE_EMAIL_CLIENT_ID, GOOGLE_EMAIL_CLIENT_SECRET, GOOGLE_EMAIL_REFRESH_TOKEN. Executes asynchronously, creates Google Email feed, and returns the feed identifier.

  • ingestMicrosoftEmail

    Ingests emails from Microsoft Email account into Graphlit knowledge base. Accepts an optional read limit for the number of emails to ingest. Requires environment variables to be configured: MICROSOFT_EMAIL_CLIENT_ID, MICROSOFT_EMAIL_CLIENT_SECRET, MICROSOFT_EMAIL_REFRESH_TOKEN. Executes asynchronously, creates Microsoft Email feed, and returns the feed identifier.

  • ingestLinearIssues

    Ingests issues from Linear project into Graphlit knowledge base. Accepts Linear project name and an optional read limit for the number of issues to ingest. Requires environment variable to be configured: LINEAR_API_KEY. Executes asynchronously, creates Linear issue feed, and returns the feed identifier.

  • ingestGitHubIssues

    Ingests issues from GitHub repository into Graphlit knowledge base. Accepts GitHub repository owner and repository name and an optional read limit for the number of issues to ingest. For example, for GitHub repository (https://github.com/openai/tiktoken), 'openai' is the repository owner, and 'tiktoken' is the repository name. Requires environment variable to be configured: GITHUB_PERSONAL_ACCESS_TOKEN. Executes asynchronously, creates GitHub issue feed, and returns the feed identifier.

  • ingestJiraIssues

    Ingests issues from Atlassian Jira repository into Graphlit knowledge base. Accepts Atlassian Jira server URL and project name, and an optional read limit for the number of issues to ingest. Requires environment variables to be configured: JIRA_EMAIL, JIRA_TOKEN. Executes asynchronously, creates Atlassian Jira issue feed, and returns the feed identifier.

  • webCrawl

    Crawls web pages from web site into Graphlit knowledge base. Accepts a URL and an optional read limit for the number of pages to crawl. Uses sitemap.xml to discover pages to be crawled from website. Executes asynchronously and returns the feed identifier.

  • webMap

    Enumerates the web pages at or beneath the provided URL using web sitemap. Does not ingest web pages into Graphlit knowledge base. Accepts web site URL as string. Returns list of mapped URIs from web site.

  • webSearch

    Performs web or podcast search based on search query. Can search for web pages or anything about podcasts (i.e. episodes, topics, guest appearances). Format the search query as what would be entered into a Google search. You can use site filtering in the search query, like 'site:twitter.com'.
    Accepts search query as string, and optional search service type.
    Prefer calling this tool over using 'curl' directly for any web search. Use 'PODSCAN' search service type to search podcasts. Does not ingest pages or podcast episodes into Graphlit knowledge base.
    When searching podcasts, don't include the term 'podcast' or 'episode' in the search query - that would be redundant. Search service types: Tavily (web pages), Exa (web pages) and Podscan (podcasts). Defaults to Exa. Returns URL, title and relevant Markdown text from resulting web pages or podcast episode descriptions.

  • ingestRSS

    Ingests posts from RSS feed into Graphlit knowledge base. For podcast RSS feeds, audio will be downloaded, transcribed and ingested into Graphlit knowledge base. Accepts RSS URL and an optional read limit for the number of posts to read. Executes asynchronously and returns the feed identifier.

  • ingestUrl

    Ingests content from URL into Graphlit knowledge base. Can scrape a single web page, and can ingest individual Word documents, PDFs, audio recordings, videos, images, or any other unstructured data. Do not use for crawling a web site, which is done with 'webCrawl' tool. Executes asynchronously and returns the content identifier.

  • ingestText

    Ingests text as content into Graphlit knowledge base. Accepts the text itself, and an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Optionally accepts the content name and an identifier for an existing content object. Will overwrite existing content, if provided. Can use for storing the output from LLM or other tools as content resources, which can be later searched or retrieved. Executes synchronously and returns the content identifier.

  • ingestMemory

    Ingests short-term textual memory as content into Graphlit knowledge base. Accepts an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Optionally accepts the content name. Will automatically be entity extracted into a knowledge graph. Use for storing short-term memories about the user or agent, which can be later searched or retrieved. Memories are transient and will be deleted after a period of time. Can use 'queryContents' or 'retrieveSources' tools to search for memories, by specifying the 'MEMORY' content type. Executes asynchronously and returns the content identifier.

  • ingestFile

    Ingests local file into Graphlit knowledge base. Accepts the path to the file in the local filesystem. Can use for storing large long-term textual memories or the output from LLM or other tools as content resources, which can be later searched or retrieved. Executes asynchronously and returns the content identifier.

  • screenshotPage

    Screenshots web page from URL. Executes synchronously and returns the content identifier.

  • describeImageUrl

    Prompts vision LLM and returns completion. Does not ingest image into Graphlit knowledge base. Accepts image URL as string. Returns Markdown text from LLM completion.

  • describeImageContent

    Prompts vision LLM and returns description of image content. Accepts content identifier as string, and optional prompt for image description. Returns Markdown text from LLM completion.

  • publishAudio

    Publishes text as audio format, and ingests into Graphlit knowledge base. Accepts a name for the content object, the text itself, and an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Optionally accepts an ElevenLabs voice identifier. You must retrieve the content resource to get the downloadable audio URL for this published audio. Executes synchronously and returns the content identifiers.

  • publishImage

    Publishes text as image format, and ingests into Graphlit knowledge base. Accepts a name for the content object. Also, accepts a prompt for image generation. For example, 'Create a cartoon image of a raccoon, saying "I Love Graphlit"'. You must retrieve the content resource to get the downloadable image URL for this published image. Executes synchronously and returns the content identifiers.

  • sendWebHookNotification

    Sends a webhook notification to the provided URL. Accepts the webhook URL. Also accepts the text to be sent with the webhook, and an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Returns true if the notification was successfully sent, or false otherwise.

  • sendSlackNotification

    Sends a Slack notification to the provided Slack channel. Accepts the Slack channel name. Also accepts the text for the Slack message, and an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Hint: In Slack Markdown, images are displayed by simply putting the URL in angle brackets like https://example.com/image.jpg instead of using the traditional Markdown image syntax alt text. Requires environment variable to be configured: SLACK_BOT_TOKEN. Returns true if the notification was successfully sent, or false otherwise.

  • sendTwitterNotification

    Posts a tweet from the configured user account. Accepts the plain text for the tweet. Tweet text rules: allowed - plain text, @mentions, #hashtags, URLs (auto-shortened), line breaks ( ).
    Not allowed - markdown, HTML tags, rich text, or custom styles. Requires environment variables to be configured: TWITTER_CONSUMER_API_KEY, TWITTER_CONSUMER_API_SECRET, TWITTER_ACCESS_TOKEN_KEY, TWITTER_ACCESS_TOKEN_SECRET. Returns true if the notification was successfully sent, or false otherwise.

  • sendEmailNotification

    Sends an email notification to the provided email address(es). Accepts the email subject and a list of email 'to' addresses. Email addresses should be in RFC 5322 format. i.e. Alice Wonderland alice@wonderland.net, or alice@wonderland.net Also accepts the text for the email, and an optional text type (Plain, Markdown, Html). Defaults to Markdown text type. Requires environment variable to be configured: FROM_EMAIL_ADDRESS. Returns true if the notification was successfully sent, or false otherwise.

Use Graphlit MCP with multiple AI models

TypingMind connects MCP tools at the workspace level, so once Graphlit is connected, you can use it with different AI models in TypingMind instead of setting it up separately for each model. This MCP runs locally through the TypingMind MCP connector on your device.

Setup guide to use the local connector

Use this when the MCP server needs access to local files, apps, or private resources on your computer.

1

Open the MCP settings

In TypingMind, go to Settings, Advanced Settings, then Model Context Protocol and choose Setup Connector.

  1. Open TypingMind in your browser.
  2. Click the Settings icon.
  3. Go to Advanced Settings.
  4. Open the Model Context Protocol section.
  5. Click Setup Connector and choose This Device.
TypingMind MCP connector setup screen with This Device selected
2

Run the connector command

Choose This Device, copy the command from TypingMind, and run it in Terminal. Keep the process running while you use MCP.

  1. Copy the setup command shown by TypingMind.
  2. Open Terminal on macOS or Windows Terminal on Windows.
  3. Paste and run the command.
  4. Approve the package install if Terminal asks you to proceed.
  5. Keep the Terminal window running while using MCP tools.
3

Add Graphlit as a server

When the connector status is Ready, click Edit Servers and paste the MCP server configuration.

  1. Wait until the connector status shows Ready.
  2. Click Edit Servers.
  3. Paste the Graphlit MCP server configuration.
  4. Save the server list.
  5. Refresh if you want to confirm the connector is still ready.
TypingMind MCP settings showing active server and Edit Servers button
{
  "mcpServers": {
    "graphlit": {
      "command": "npx",
      "args": [
        "-y",
        "graphlit-mcp-server"
      ]
    }
  }
}
4

Use it across models

Save the server list, open Plugins, enable the Graphlit MCP tools, then select any supported AI model in TypingMind and use the tools in chat or assign them to an AI agent.

  1. Open the Plugins page in TypingMind.
  2. Enable the Graphlit MCP tools.
  3. Start a chat and choose the AI model you want to use.
  4. Use the MCP tools in chat or assign them to an AI agent.
  5. Switch to another AI model whenever needed without reconnecting MCP.
TypingMind chat using enabled MCP tools with a selected AI model
Can you use Graphlit to help me with this task?
Graphlit
Sure. I read it.
Here is what I found using Graphlit.

Frequently asked questions

What is the Graphlit MCP server used for?

Graphlit is an MCP server that lets compatible AI clients connect to external tools and context. In TypingMind, you can add this MCP server once and make its tools available in your AI workspace.

Can I use Graphlit MCP with multiple AI models in TypingMind?

Yes. TypingMind connects MCP tools at the workspace level, so you can use Graphlit with different AI models such as Claude, ChatGPT, Gemini, or other models you have configured in TypingMind without setting up the MCP server separately for each model.

Why use Graphlit MCP with TypingMind?

TypingMind is one of the best frontends for LLM chat because it brings multiple AI models, prompts, plugins, AI agents, API keys, and MCP tools into one workspace. With Graphlit connected, you can use its MCP tools across your preferred models while keeping your chat workflow organized in TypingMind.

How do I connect Graphlit MCP to TypingMind?

Graphlit runs through the TypingMind local MCP connector. This is best when the MCP server needs access to local files, desktop apps, command-line tools, or private resources on your computer.

What tools does Graphlit MCP provide in TypingMind?

Graphlit exposes 64 MCP tools that can be enabled from the TypingMind Plugins page and used in chat or assigned to AI agents.

Do I need to share my API keys with TypingMind to use Graphlit MCP?

No. TypingMind is local-first and lets you keep your model providers, API keys, prompts, and MCP configuration under your control. If Graphlit requires authentication, add the required headers, OAuth settings, or local configuration for that MCP server when you create the connection.

Related MCP Servers

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇