Graphory logo

Graphory

Getting Started

Go from zero to your first AI-powered query in under 5 minutes. No code required: sign up, connect Gmail (or any source), point your AI at Graphory, and start asking questions.

No-code Path (recommended)

Most users never need to install anything on their own machine. Sign up, connect a source in the web dashboard, generate an API key, paste it into your AI client's MCP config, and you are done. The rest of the work happens through natural conversation with your AI.

Sign up at app.graphory.io

Create your account at app.graphory.io. Sign in with Google or email. You will be guided through creating your first organization.

Connect Gmail (or any source) in the dashboard

Open the Connections page and pick your first source. For OAuth sources like Gmail, Google Workspace, Slack, and Salesforce, you bring your own OAuth credentials (client ID + client secret, or a long-lived refresh token) and paste them into the connections panel. For personal-access-token sources like GitHub, Notion, or Linear, paste the token. Either way Graphory stores the credential encrypted in your org's WorkOS Vault - the only OAuth flow Graphory itself operates is WorkOS AuthKit for signup and login.

Popular first connections: Gmail, Google Calendar, Slack, QuickBooks, or GitHub.

Two-phase ingestion. When you ingest data (from a connected source or via the Ingest API), the source file lands immediately and becomes full-text searchable via search_graph. Graph extraction, which populates typed nodes and edges queryable by get_entity, traverse, and timeline, runs on a nightly pipeline or on-demand via sync_graph. This means recent data is searchable right away but may not appear as typed graph entities for a few minutes to a few hours.

Generate an API key

Go to Settings > API Keys and click Create Key. Copy the key - it starts with gs_ak_ and will only be shown once.

Store your API key securely. It provides full access to your organization's data. If compromised, revoke it immediately from the Settings page.

Point your AI at Graphory via MCP

Paste the MCP config into your AI client once. After that you can just ask things like "connect my Slack to Graphory" or "what did Sarah say about the renewal?". Choose your platform below and follow the configuration instructions. Replace YOUR_API_KEY with the key you generated in the previous step.

Ask Claude Desktop (or any AI) your first question

Once MCP is wired up, start a conversation and ask:

You
What's in my Graphory graph? Give me a summary.

Your AI will call graph_stats and setup_status and report back. From there, ask anything - connect more sources, run searches, trigger syncs, write findings back - all through conversation.

Add this to your Claude Desktop config file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "graphory": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.graphory.io/mcp",
        "--header",
        "Authorization: Bearer YOUR_API_KEY"
      ]
    }
  }
}

Restart Claude Desktop completely. Graphory tools will appear in the hammer icon menu.

Run this command in your terminal:

bash
claude mcp add-json graphory '{"type":"http","url":"https://api.graphory.io/mcp","headers":{"Authorization":"Bearer YOUR_API_KEY"}}'

Graphory tools will be available in your next Claude Code session.

ChatGPT supports MCP through its developer mode:

  1. Go to Settings > Apps > Advanced
  2. Enable Developer Mode
  3. Click Create app
  4. Enter the MCP URL: https://api.graphory.io/mcp
  5. Add the Authorization: Bearer YOUR_API_KEY header

Add to your Gemini settings file at ~/.gemini/settings.json:

~/.gemini/settings.json
{
  "mcpServers": {
    "graphory": {
      "httpUrl": "https://api.graphory.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Add to ~/.cursor/mcp.json:

~/.cursor/mcp.json
{
  "mcpServers": {
    "graphory": {
      "type": "streamable-http",
      "url": "https://api.graphory.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json:

mcp_config.json
{
  "mcpServers": {
    "graphory": {
      "serverUrl": "https://api.graphory.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Add to .vscode/mcp.json in your project root. Note: the root key is "servers", not "mcpServers".

.vscode/mcp.json
{
  "servers": {
    "graphory": {
      "type": "http",
      "url": "https://api.graphory.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Add to ~/.codex/config.toml:

~/.codex/config.toml
[mcp_servers.graphory]
url = "https://api.graphory.io/mcp"
bearer_token_env_var = "GRAPHORY_API_KEY"
enabled = true

Set the environment variable: export GRAPHORY_API_KEY=gs_ak_your_key

Register Graphory in OpenClaw's MCP servers config. OpenClaw's exact schema evolves - see the OpenClaw integration page and OpenClaw's own docs for the current shape:

OpenClaw MCP config
{
  "mcpServers": {
    "graphory": {
      "url": "https://api.graphory.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
Python
import httpx

API = "https://api.graphory.io"
KEY = "gs_ak_your_key"
headers = {"Authorization": f"Bearer {KEY}"}

r = httpx.post(
    f"{API}/org/YOUR_ORG_ID/search",
    headers=headers,
    json={"q": "revenue", "limit": 10}
)
print(r.json())
curl
curl -X POST https://api.graphory.io/org/YOUR_ORG_ID/search \
  -H "Authorization: Bearer gs_ak_your_key" \
  -H "Content-Type: application/json" \
  -d '{"q": "revenue", "limit": 10}'

Developers

If you want programmatic access (scripts, CI jobs, notebooks), install the Python SDK. Everything the SDK does is also available through MCP and the raw HTTP API, so this track is optional.

Install the Graphory CLI and log in

The graphory Python package wraps the Graph API and the Ingest API in a small SDK.

Install and log in
pip install graphory
graphory login
# Paste your gs_ak_ API key when prompted
# Paste your org_id (from Settings)

Once logged in, your credentials live in ~/.graphory/config.json and any Python script can call Graphory.from_config() to use them.

Quickstart in Python
from graphory import Graphory
g = Graphory.from_config()
print(g.stats())
results = g.search("invoices from last quarter")

AI-First Onboarding

After signing up and adding the MCP config to your AI client, you can complete the rest of the setup entirely through conversation. This is the recommended flow for users who prefer working through their AI.

Sign up and add MCP config

Create your account at app.graphory.io, generate an API key, and add the MCP config to your AI client (see platform tabs above). This is the only step that requires the dashboard.

Ask your AI to check setup status

Start a conversation with your AI and ask:

You
What's my Graphory setup status? What do I need to do next?

Your AI will call the setup_status tool and tell you exactly what steps remain.

Connect sources through your AI

Tell your AI which data sources to connect:

You
Connect my Gmail and Slack to Graphory.

Your AI will call connect_source for each app. For OAuth apps, it will tell you which credentials to bring (your own OAuth client ID + client secret, or an existing refresh token) and either paste them via connect_custom_source or point you at the connections page to paste them yourself. Graphory stores them encrypted in your WorkOS Vault. If a credential later breaks upstream, the next collection emits a connection_error notification with the system slug, the exact provider error, and the fix - your AI sees it and walks you through rotating the token.

Configure and start collecting

Tell your AI how you want data collected:

You
Set Gmail to sync hourly and pull the last 90 days of emails. Start collecting now.

Your AI configures collection and triggers the first sync using configure_collection.

Start querying

Once data is flowing, ask anything:

You
Who have I been emailing the most this month? Show me the key contacts.

Your AI searches your graph and presents insights from your connected data sources.

The AI-first flow means you never need to leave your AI conversation to manage Graphory. Connect sources, check health, configure collection, query data, and write back insights - all through natural language.

MCP Setup Checklist

Quick reference for connecting any MCP-compatible client:

  1. Sign up at app.graphory.io and create an organization
  2. Go to Settings > API Keys and create a key (starts with gs_ak_)
  3. Add the MCP config to your AI client (see platform tabs above)
  4. Restart your AI client completely
  5. Verify by asking: "What Graphory tools do you have available?"
  6. Connect your first data source: "Connect my Gmail to Graphory"
  7. Wait for first sync (usually a few minutes), then start querying

What's Next?