tigergraph-mcp
OfficialA TigerGraph MCP server that lets AI agents explore, modify, query, and vector-search TigerGraph databases across multiple connection profiles.
Connections & sessions — list/show configured profiles, register per-session credentials (
authenticate), route calls to a specific environment with theprofileargument.Schema & graphs — list graphs, read global/graph schema as structured JSON, show full graph details (schema, queries, jobs, data sources), validate names against GSQL keywords, create graphs, apply incremental schema changes, drop graphs or clear data.
Vertices & edges — add/get/delete vertices and edges (single or batch), check existence, list edges of a node, get 1-hop neighbors, degree, vertex/edge counts.
Queries — run ad-hoc interpreted GSQL or openCypher, install/drop/re-run compiled queries, inspect query text and metadata, set and read query/parameter descriptions, plus LLM-powered
generate_gsqlandgenerate_cypher.Raw GSQL — execute arbitrary GSQL commands for administrative or schema tasks.
Data loading — create loading jobs from files or warehouse SQL, run jobs from a file or inline data, list jobs, check job status, drop jobs.
Vector search (TigerVector) — add/drop/list vector attributes, check index status, upsert vectors, bulk-load vectors from CSV or JSON Lines, top-K similarity search, fetch stored vectors.
Data sources — create/update/get/drop data sources (S3, GCS, Azure Blob, Snowflake, BigQuery, PostgreSQL, Iceberg, Kafka/MirrorMaker), list supported types and their config keys, preview sample data.
Discovery helpers — search tools by task, get step-by-step workflow templates, and fetch detailed info on individual tools.
Allows creating and managing PostgreSQL data sources to load data into TigerGraph.
Allows creating and managing Snowflake data sources to load data into TigerGraph.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@tigergraph-mcp show me the schema of the graph"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
tigergraph-mcp
Model Context Protocol (MCP) server for TigerGraph — lets AI agents interact with TigerGraph through the MCP standard. All tools use pyTigerGraph's async APIs for optimal performance.
Table of Contents
Related MCP server: Memgraph MCP Server
Requirements
Python 3.10 through 3.14
MCP SDK 1.x or 2.x — the server works with either generation of the
mcppackage. Client code differs between them; see MCP SDK over HTTP.TigerGraph 4.1 or later — Install from the TigerGraph Downloads page or use TigerGraph Savanna for a managed cloud instance.
Recommended: TigerGraph 4.2+ to enable TigerVector and advanced hybrid retrieval features.
Installation
Install with pip:
pip install tigergraph-mcpOr with conda (from the tigergraph channel):
conda install -c tigergraph tigergraph-mcpThis installs:
pyTigerGraph>=2.0.5— the TigerGraph Python SDKmcp>=1.0.0— the MCP SDKpydantic>=2.0.0— for data validationclick— for the CLI entry pointpython-dotenv>=1.0.0— for loading.envfiles
To serve over HTTP (--transport streamable-http or sse), also install a web stack:
pip install uvicorn starletteTo enable the tigergraph__generate_gsql and tigergraph__generate_cypher tools (LLM-powered query generation), install the optional [llm] extras (pip only):
pip install "tigergraph-mcp[llm]"Getting Started
TigerGraph-MCP supports multiple AI agent frameworks. Choose the one that fits your workflow:
LangGraph (Recommended)
LangGraph is ideal for building stateful, agent-based workflows with complex tool chaining. Setup guide and full chatbot example:
CrewAI
CrewAI provides a simpler starting point for basic agentic workflows with a web-based UI:
GitHub Copilot Chat (VS Code)
For quick tasks or straightforward tool invocations directly in your editor:
Usage
Running the MCP Server
stdio (default — single user, one IDE/agent)
tigergraph-mcpThe server talks MCP over its own stdin and stdout: it reads JSON-RPC messages from standard input and writes replies to standard output, then exits when standard input closes. Run it in a terminal and it simply waits for messages — there is no prompt and no human-facing console. You normally never start it this way; the MCP client (Claude Code, Cursor, GitHub Copilot Chat, a LangChain agent) spawns it as a subprocess and owns the pipes. Running it by hand is mainly useful for checking that it starts:
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"manual","version":"1"}}}' \
| tigergraph-mcpBecause the client owns the process, credentials must reach it as environment variables —
from a .env file, or from the client's own env mapping. This is the right mode for any
single-user IDE integration.
With a custom .env file:
tigergraph-mcp --env-file /path/to/.envWith verbose logging:
tigergraph-mcp -v # INFO level
tigergraph-mcp -vv # DEBUG levelOr programmatically:
from tigergraph_mcp import serve
import asyncio
asyncio.run(serve())Streamable HTTP / SSE (multi-user, shared server)
tigergraph-mcp --transport streamable-http --host 0.0.0.0 --port 8000
# legacy SSE shape:
tigergraph-mcp --transport sse --host 0.0.0.0 --port 8000Here the server binds the chosen port and serves MCP over HTTP, staying up until you
stop it — a long-lived service you start once, not a process a client spawns. Many clients
connect to it concurrently, each getting its own isolated TigerGraph connections, and it
does not read standard input at all. Requires uvicorn and starlette.
HTTP Mode End-to-End walks through configuring, starting, and connecting to one.
Use with Claude Code
tigergraph-mcp ships as a Claude Code plugin, which replaces installing the package,
writing a .env, and hand-writing an MCP client config. Claude Code prompts for the
connection details and launches the server itself.
Requires uv on your PATH — the plugin runs the server with
uvx, which fetches it from PyPI on demand. uv can also provide a suitable Python, so
nothing else needs installing.
claude plugin marketplace add tigergraph/tigergraph-mcp
claude plugin install tigergraph@tigergraphClaude Code then asks for the TigerGraph host (required), and optionally a username,
password, default graph, API token, and a tool selection. The password and API token are
masked and held in secure storage rather than a settings file. To change any of them
later, open /plugin, select TigerGraph (Self-Managed MCP) on the Installed tab,
and choose Configure options — no reinstall needed.
Supplying an API token makes it take precedence over the password.
The tool selection accepts the same selectors as --allowed-tools
(Serving a Subset of the Tools); leaving it empty offers
all of them.
In permission rules, a skill's allowed-tools, or a hook matcher, the plugin's server is
named plugin:tigergraph:tigergraph. A pattern like mcp__tigergraph__.* does not
match a plugin-provided server.
If you would rather not install uv, install the package yourself and point a plain MCP
client config at the tigergraph-mcp command, as in
stdio above.
Configuration
The MCP server reads connection configuration from environment variables. You can set these either directly or in a .env file.
Using a .env File (Recommended)
Create a .env file in your project directory:
# .env — Username/Password authentication
TG_HOST=http://localhost
TG_GRAPHNAME=MyGraph # Optional — can be omitted if the database has multiple graphs
TG_USERNAME=tigergraph
TG_PASSWORD=tigergraph
TG_RESTPP_PORT=9000
TG_GS_PORT=14240Or use an API token instead of username/password:
# .env — API Token authentication
TG_HOST=http://localhost
TG_GRAPHNAME=MyGraph
TG_API_TOKEN=your_api_token_hereWhen TG_API_TOKEN (or TG_JWT_TOKEN) is set, the server uses token-based authentication (Authorization: Bearer <token>) and ignores username/password. You can obtain a token via pyTigerGraph's getToken() method or by directly calling TigerGraph's token generation endpoint.
When only username/password are provided and the TigerGraph instance requires a token for RESTPP endpoints, pyTigerGraph auto-mints one on the first 401 response and transparently retries the request — no manual token setup needed.
The server loads the .env file automatically. Environment variables take precedence over .env values.
Environment Variables
Variable | Default | Description |
|
| TigerGraph host |
| (empty) | Graph name (optional) |
|
| Username |
|
| Password |
| (empty) | GSQL secret (optional) |
| (empty) | API token (optional) |
| (empty) | JWT token (optional) |
|
| REST++ port |
|
| GSQL port |
|
| SSL port |
|
| Whether using TigerGraph Cloud |
| (empty) | Path to certificate (optional) |
|
| Log one line per tool call |
|
| Caller identity in those lines: |
Multiple Connection Profiles
Define named profiles in your .env to work with multiple TigerGraph environments without changing any code.
Defining profiles
Each named profile uses a <PROFILE>_ prefix on the standard TG_* variables. Only variables that differ from the default need to be set.
# .env
# Default profile (no prefix) — password auth
TG_HOST=http://localhost
TG_USERNAME=tigergraph
TG_PASSWORD=tigergraph
TG_GRAPHNAME=MyGraph
# Staging profile — token auth
STAGING_TG_HOST=https://staging.example.com
STAGING_TG_API_TOKEN=staging_token_here
STAGING_TG_TGCLOUD=true
# Production profile — password auth
PROD_TG_HOST=https://prod.example.com
PROD_TG_USERNAME=admin
PROD_TG_PASSWORD=prod_secret
PROD_TG_GRAPHNAME=ProdGraph
PROD_TG_TGCLOUD=trueProfiles are discovered automatically at startup. Any variable matching <PROFILE>_TG_HOST registers a new profile. Values not set for a named profile fall back to the default profile's values.
Selecting the default profile
# Switch to staging for this run
TG_DEFAULT_PROFILE=staging tigergraph-mcp
# Or set permanently in .env
TG_DEFAULT_PROFILE=prodTG_DEFAULT_PROFILE names the profile used when a call does not specify one. If it is not set, the unprefixed TG_* variables are the default profile. TG_PROFILE is accepted as an alias.
Omitting the profile argument and passing profile="default" mean the same thing — the default profile — in both stdio and HTTP mode.
Switching profiles per call
Every tool accepts an optional profile argument, so an agent can route individual calls to different environments without restarting the server. Connections are pooled per profile and reused across calls. list_connections reports the configured profiles, which one is the default, and which are currently connected — in HTTP mode scoped to the calling session.
User: Compare the vertex count of MyGraph between staging and prod.
Agent:
→ get_vertex_count(profile="staging", graph_name="MyGraph")
→ get_vertex_count(profile="prod", graph_name="MyGraph")
User: Show me the schema on staging, then run this GSQL on prod:
SHOW VERTEX Person
Agent:
→ get_graph_schema(profile="staging", graph_name="MyGraph")
→ gsql(profile="prod", command="SHOW VERTEX Person")Helping the agent pick the right environment
Users normally name an environment the way it is configured — "staging", "the prod
cluster". list_connections reports each profile's name and its host, so the agent can
also resolve the occasional bare hostname or URL to the profile that reaches it:
{
"default_profile": "dev",
"profiles": [
{"profile": "dev", "host": "http://localhost", "username": "tigergraph", "is_default": true, "connected": true},
{"profile": "prod", "host": "https://mycompany.i.tgcloud.io", "username": "analyst", "is_default": false, "connected": false},
{"profile": "staging", "host": "https://tg-staging.example.com", "username": "analyst", "is_default": false, "connected": false}
]
}Note that prod's host carries no hint of the profile name, so a user who names that
host cannot be served by guessing from profile names alone.
A system prompt that puts that to work:
You are a TigerGraph assistant. The tigergraph-mcp server may be configured
with several environments, each identified by a profile name.
Discovering profiles
- Call `list_connections` before your first data access, and again whenever
the user mentions an environment you have not seen.
- Each profile reports its name, host, and username, which one is the
default, and which are already connected.
- Never invent or hardcode a profile name.
Choosing one
- Users normally name an environment, not a machine. If the user names a
profile ("use staging", "on the prod cluster"), use that profile.
- If the user names a host or URL instead, match it against the `host`
field. Several profiles may share one host, differing only in the user
they connect as. In that case run the request against every matching
profile and report the results per profile, rather than asking which
one was meant.
- If nothing matches what the user named, say so and list the configured
profiles with their hosts. Do not guess.
- If the user says nothing about an environment, use the default profile
and mention which one you used.
Using one
- Pass `profile="<name>"` on every tool call meant for that environment.
- A single turn may use different profiles when the user compares
environments.
Reporting
- Answer about the environments the user asked about. Do not list the
profiles you considered and skipped, and do not narrate the lookup.
- Name the environment alongside each answer, so the user knows which
one it came from — especially when reporting more than one.With that prompt, a site named in plain language resolves to a profile:
User: How many vertices does MyGraph have on staging?
Agent:
→ get_vertex_count(profile="staging", graph_name="MyGraph")
"On staging: 1,204 vertices."
User: And on mycompany.i.tgcloud.io? # a host, not an environment
Agent: # tool calls, not shown to the user
→ list_connections() # prod and prod_ro share that host
→ get_vertex_count(profile="prod", graph_name="MyGraph")
→ get_vertex_count(profile="prod_ro", graph_name="MyGraph")
Agent replies:
"Two profiles reach that host:
prod (as analyst): 1,204 vertices
prod_ro (as readonly): 1,204 vertices"The reply names the environment behind each number and says nothing about dev or
staging, which the user did not ask about.
Omitting profile, or passing "default", uses the default profile — TG_DEFAULT_PROFILE if set (or its alias TG_PROFILE), otherwise the unprefixed TG_* variables.
HTTP Mode End-to-End
Run one shared server that several people or services connect to. Five steps.
1. Install with the web stack
pip install tigergraph-mcp uvicorn starlette2. Describe your TigerGraph sites
Put the environments in an env file. The unprefixed TG_* variables are the default
profile; each <NAME>_TG_* group adds another. Credentials here are optional — include
them for a shared or demo deployment, omit them to require every client to send its own:
# /etc/tigergraph-mcp/.env
TG_DEFAULT_PROFILE=prod
PROD_TG_HOST=https://mycompany.i.tgcloud.io
PROD_TG_USERNAME=analyst
PROD_TG_PASSWORD=...
STAGING_TG_HOST=https://tg-staging.example.com
STAGING_TG_USERNAME=analyst
STAGING_TG_PASSWORD=...3. Start the server
tigergraph-mcp --transport streamable-http \
--host 0.0.0.0 --port 8000 \
--env-file /etc/tigergraph-mcp/.envIt binds the port and serves until stopped, so run it under systemd, a container, or whatever supervises your services. Put a reverse proxy or API gateway in front for TLS and to control who may reach the URL.
4. Check that it is up
curl -s -o /dev/null -w '%{http_code}\n' -X POST http://localhost:8000/mcp/ \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'Response | Meaning |
| Up, and the default profile's credentials work |
| Up, but the request does not name a reachable site (e.g. an unknown profile) |
| Up, but no usable credentials — the client must send them |
| Up, but TigerGraph itself could not be reached |
| You omitted the trailing slash on |
connection refused | The server is not running |
5. Point a client at it
The URL is http://<host>:<port>/mcp/ — keep the trailing slash. Credentials, when the
client supplies them, travel as X-TG-* headers; omit them to use the server's default
profile as configured.
Cursor, VS Code, or any editor using mcp.json:
{
"servers": {
"tigergraph-mcp-server": {
"type": "http",
"url": "http://localhost:8000/mcp/",
"headers": {
"X-TG-Profile": "staging"
}
}
}
}The scheme is whatever the server is reachable on. tigergraph-mcp itself serves plain
HTTP and does not terminate TLS, so use http:// when connecting to it directly. A
deployed instance normally sits behind a reverse proxy that adds TLS, in which case the
URL is the proxy's — https://my-tg-mcp.internal/mcp/. Credentials travel in headers, so
anything beyond localhost should be https://.
To connect as yourself rather than as the profile's configured user, add your own credentials — keeping secrets out of the file by referencing the environment:
"headers": {
"X-TG-Host": "https://mycompany.i.tgcloud.io",
"X-TG-Api-Token": "${env:TG_API_TOKEN}"
}Python, LangChain, or any MCP SDK client: see Client Examples for
runnable versions of both. The HTTP client API differs between MCP SDK generations, so
check which one you have with pip show mcp:
# MCP SDK 2.x
import httpx2
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
async with httpx2.AsyncClient(headers={"X-TG-Profile": "staging"}) as http_client:
async with streamable_http_client(
"http://localhost:8000/mcp/", http_client=http_client
) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
await session.call_tool("tigergraph__list_graphs", {})# MCP SDK 1.x
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
async with streamablehttp_client(
"http://localhost:8000/mcp/", headers={"X-TG-Profile": "staging"}
) as (read, write, _):
async with ClientSession(read, write) as session:
await session.initialize()
await session.call_tool("tigergraph__list_graphs", {})Which connection a request gets
Profiles come from the server's env file, exactly as in Multiple Connection
Profiles above. A request picks one with X-TG-Profile,
and any other X-TG-* header overrides that profile's value for that session only:
Headers sent | Connection used |
| that profile's topology and its configured credentials |
| that profile's topology, the caller's identity |
Credential headers only | the default profile's topology, the caller's identity |
No headers | the default profile exactly as configured |
Whether profiles carry credentials at all is your decision when writing the env file. Credentials there are a shared identity usable by anyone who can reach the server, which suits a demo or single-user deployment; an env file with topology only forces every caller to identify itself, which is what you want when several people share the server.
Recognised headers mirror the TG_* variables used in stdio mode:
Header | Env-var equivalent |
| selects a server-side profile ( |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Once connected, a tool call may still name any configured profile with its profile
argument; that connection opens in the calling session and is never shared with another.
Serving several users
Each session gets its own connections, so concurrent users never share state or credentials. Two patterns work:
Each person's editor connects directly, with their own profile or credentials in
mcp.json— the configuration shown above.An application connects on its users' behalf, opening one session per logged-in user with that user's credentials in the headers, held for their lifetime so the LLM never sees credentials. A working reference is in
examples/multi_user_backend/.
Two settings matter for a long-running server: TG_HTTP_SESSION_IDLE_TIMEOUT (default
900s) reclaims connections from sessions that have gone quiet, and
TG_HTTP_ALLOWED_PROFILES=demo,staging narrows which profiles clients may name.
Access control to the endpoint itself is the deployment's responsibility — the server checks TigerGraph credentials, not who may reach the URL. Put a reverse proxy or API gateway in front, which is also where TLS belongs.
The authenticate tool can re-point a live session mid-conversation, which is not needed
when credentials arrive as headers.
Serving a Subset of the Tools
All 69 tools are offered by default. An agent carries every tool it is given on every request, so a deployment that only needs some of them can say so:
# only the tools that read
tigergraph-mcp --allowed-tools read-only
# a task-shaped subset
tigergraph-mcp --allowed-tools schema,query
# everything except the ones that remove data
tigergraph-mcp --blocked-tools destructiveTG_ALLOWED_TOOLS and TG_BLOCKED_TOOLS do the same from the environment or an env file;
the flags win where both are set.
A selector is a comma-separated list of:
Selector | Meaning |
| a category |
| the tools that change nothing |
| the tools that may remove or overwrite something |
| one tool, with or without the prefix |
--blocked-tools is applied after --allowed-tools, so
--allowed-tools schema --blocked-tools drop_graph serves the schema tools without that one.
An unrecognised selector stops the server at startup rather than quietly serving a short
list, and a selection that leaves nothing to serve is likewise an error.
Roughly what each choice costs an agent:
Served | Tools | ~Tokens |
everything | 69 | 29,100 |
| 37 | 12,400 |
| 21 | 9,100 |
Note that discovery and utility are not added automatically. If you narrow by category,
include them where the agent needs to discover tools or route calls by profile:
--allowed-tools schema,query,discovery,utility.
Per-session narrowing over HTTP
A client may restrict its own session with an X-TG-Tools header, using the same
selectors:
{
"servers": {
"tigergraph-mcp-server": {
"type": "http",
"url": "http://localhost:8000/mcp/",
"headers": {
"X-TG-Profile": "prod",
"X-TG-Tools": "read-only"
}
}
}
}This only ever narrows. A session cannot reach a tool the deployment withheld, so asking
for destructive on a server started with --blocked-tools destructive yields no tools
rather than the blocked ones.
What a tool declares about itself
Every tool carries the MCP behavioural hints, which is how an editor decides whether to run something silently or ask first:
"annotations": {
"title": "Drop graph",
"readOnlyHint": false,
"destructiveHint": true,
"idempotentHint": true,
"openWorldHint": false
}These reach the client, not the model, so they cost nothing in context. read-only and
destructive selectors resolve from the same classification. Tools that execute
caller-supplied query text — gsql, run_query, run_installed_query — are marked
destructive, because what they do depends on the text they are given.
Logging Tool Calls
Nothing is logged about tool calls by default. A shared deployment usually wants a record of what has been run against an instance:
tigergraph-mcp --transport streamable-http --log-tool-callsOne line per call goes to stderr:
tool call tool=tigergraph__drop_graph session=b1f2c3 host=https://mycompany.i.tgcloud.ioWho made the call is a separate opt-in, because a TigerGraph account name generally
identifies a person. It requires --log-tool-calls — on its own it does nothing, and the
server says so at startup:
# the connection profile the call used
tigergraph-mcp --log-tool-calls --log-caller profile
# the TigerGraph account as well
tigergraph-mcp --log-tool-calls --log-caller username
| Line carries |
| tool, session, host |
| the above, plus the connection profile |
| the above, plus the account name and how it authenticated |
tool call tool=tigergraph__drop_graph session=b1f2c3 host=https://mycompany.i.tgcloud.io profile=prod user=alice auth=passwordTG_LOG_TOOL_CALLS and TG_LOG_CALLER_IDENTITY do the same from the environment or an env
file; the flags win where both are set. TG_LOG_CALLER_IDENTITY is gated the same way, so
leaving it in an env file has no effect until tool-call logging is turned on — and turning
it on later will not silently start writing account names.
Two things to know before turning on username:
Callers who authenticate with a token or a GSQL secret appear as
user=-. TigerGraph tokens do not tell the server which account is behind them, so there is no name to record.The logs then contain personal data. Whatever retention, access, and disclosure rules apply to your other logs apply to these.
profileis the smaller disclosure and is often enough — it says which configured connection was used without naming anyone.
In stdio mode there is a single configured identity for the process, so every line carries the same profile and account. The record is more useful over HTTP, where each session authenticates separately.
Never logged, at any setting: passwords, GSQL secrets, API and JWT tokens, and tool arguments — arguments hold query text and vertex payloads, which is graph data rather than an audit record. Access to the endpoint itself is still the deployment's concern; a reverse proxy is where request-level access logs belong.
Using with Existing Connection
from pyTigerGraph import AsyncTigerGraphConnection
from tigergraph_mcp import ConnectionManager
async with AsyncTigerGraphConnection(
host="http://localhost",
graphname="MyGraph",
username="tigergraph",
password="tigergraph",
) as conn:
ConnectionManager.set_default_connection(conn)
# ... run MCP tools ...
# HTTP connection pool is released on exitClient Examples
Hold one session for the run.
MultiServerMCPClient(...)connects nothing, andawait client.get_tools()opens a session only to list the tools, then closes it — the returned tools carry a connection config, so each tool call opens a new session. Over stdio that spawns atigergraph-mcpprocess per call; over HTTP it creates a session, a connection, and a credential check per call. Binding tools to a session held open byclient.session(...)reuses one process (or one session and its pooled connection) for the whole run — in a measured 8-call agent run, 1 session instead of 9, and roughly 4× faster. Useget_tools()only for one-shot scripts.
LangChain / LangGraph over stdio
The client starts tigergraph-mcp as a subprocess and passes credentials as env vars.
import asyncio
from pathlib import Path
from dotenv import dotenv_values
from langchain.chat_models import init_chat_model
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
env_dict = dotenv_values(dotenv_path=Path(".env").expanduser().resolve())
client = MultiServerMCPClient(
{
"tigergraph-mcp-server": {
"transport": "stdio",
"command": "tigergraph-mcp",
"args": ["-vv"],
"env": env_dict,
},
}
)
async def main():
# One session for the whole run; every tool call reuses it.
async with client.session("tigergraph-mcp-server") as session:
tools = await load_mcp_tools(session)
agent = create_react_agent(init_chat_model("openai:gpt-4.1-mini"), tools)
result = await agent.ainvoke(
{"messages": [{"role": "user", "content": "Which graphs are available?"}]}
)
print(result["messages"][-1].content)
asyncio.run(main())create_react_agent is one option; init_chat_model(...).bind_tools(tools) works too if
you are driving the model yourself. Either way, build the agent inside the session so
the tools stay bound to it.
Note: Instead of loading a
.envfile, you can pass credentials directly in theenvmapping:"env": { "TG_HOST": "http://localhost", "TG_USERNAME": "tigergraph", "TG_PASSWORD": "tigergraph", "TG_GRAPHNAME": "MyGraph" }Either way the credentials must be in
env: the subprocess does not inherit your shell environment.
LangChain / LangGraph over HTTP
The server is already running elsewhere; the client only connects. Credentials travel as headers, so nothing about TigerGraph needs to be configured on this side.
import asyncio
from langchain.chat_models import init_chat_model
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
client = MultiServerMCPClient(
{
"tigergraph-mcp-server": {
"transport": "streamable_http",
"url": "http://localhost:8000/mcp/", # trailing slash required
"headers": {
# Omit these entirely to use the server's default profile.
"X-TG-Profile": "staging",
"X-TG-Username": "my_user",
"X-TG-Password": "my_password",
},
},
}
)
async def main():
async with client.session("tigergraph-mcp-server") as session:
tools = await load_mcp_tools(session)
agent = create_react_agent(init_chat_model("openai:gpt-4.1-mini"), tools)
result = await agent.ainvoke(
{"messages": [{"role": "user", "content": "How many vertices are in MyGraph?"}]}
)
print(result["messages"][-1].content)
asyncio.run(main())MCP SDK over stdio
stdio_client does not pass your environment to the subprocess — it forwards only a
minimal safe set (HOME, PATH, SHELL, …). Credentials must be supplied explicitly
via env, or the server will fall back to its defaults and try http://127.0.0.1.
import asyncio
from pathlib import Path
from dotenv import dotenv_values
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import get_default_environment, stdio_client
env_dict = dotenv_values(dotenv_path=Path(".env").expanduser().resolve())
async def main():
server_params = StdioServerParameters(
command="tigergraph-mcp",
args=["-vv"],
env={**get_default_environment(), **env_dict},
)
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
tools = await session.list_tools()
print(f"Available tools: {[t.name for t in tools.tools]}")
result = await session.call_tool("tigergraph__list_graphs", arguments={})
for content in result.content:
print(content.text)
asyncio.run(main())MCP SDK over HTTP
The HTTP client API changed between MCP SDK generations. Check yours with pip show mcp
— a fresh pip install currently gets 2.x. In 1.x the function took headers and yielded
three values; in 2.x it takes an http_client carrying the headers and yields two.
# MCP SDK 2.x
import asyncio
import httpx2
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
URL = "http://localhost:8000/mcp/" # trailing slash required
HEADERS = { # omit to use the default profile
"X-TG-Profile": "staging",
}
async def main():
async with httpx2.AsyncClient(headers=HEADERS) as http_client:
async with streamable_http_client(URL, http_client=http_client) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
tools = await session.list_tools()
print(f"Available tools: {[t.name for t in tools.tools]}")
# Every call reuses this session's pooled connection.
result = await session.call_tool("tigergraph__list_graphs", arguments={})
for content in result.content:
print(content.text)
# Route one call to another configured profile.
await session.call_tool(
"tigergraph__list_graphs", arguments={"profile": "prod"}
)
asyncio.run(main())# MCP SDK 1.x
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
URL = "http://localhost:8000/mcp/"
HEADERS = {"X-TG-Profile": "staging"}
async def main():
async with streamablehttp_client(URL, headers=HEADERS) as (read, write, _):
async with ClientSession(read, write) as session:
await session.initialize()
result = await session.call_tool("tigergraph__list_graphs", arguments={})
for content in result.content:
print(content.text)
asyncio.run(main())Available Tools
Global Schema Operations
tigergraph__get_global_schema— Get the complete global schema via GSQLLS
Graph Operations
tigergraph__list_graphs— List all graph names in the databasetigergraph__create_graph— Create a new graph with schematigergraph__drop_graph— Drop a graph and its schematigergraph__clear_graph_data— Clear all data from a graph (keeps schema)
Schema Operations
tigergraph__get_graph_schema— Get schema as structured JSONtigergraph__show_graph_details— Show schema, queries, loading jobs, and data sources
Node Operations
tigergraph__add_node/tigergraph__add_nodestigergraph__get_node/tigergraph__get_nodestigergraph__delete_node/tigergraph__delete_nodestigergraph__has_nodetigergraph__get_node_edges
Edge Operations
tigergraph__add_edge/tigergraph__add_edgestigergraph__get_edge/tigergraph__get_edgestigergraph__delete_edge/tigergraph__delete_edgestigergraph__has_edge
Query Operations
tigergraph__run_query— Run an interpreted querytigergraph__run_installed_query— Run an installed querytigergraph__install_query/tigergraph__drop_querytigergraph__show_query/tigergraph__get_query_metadata/tigergraph__is_query_installedtigergraph__update_query_description/tigergraph__get_query_description— Set or read query and per-parameter descriptions (TigerGraph 4.0+)tigergraph__get_neighbors
Loading Job Operations
tigergraph__create_loading_job— from files, or from adata_source+querypair to load the result of a SQL query against a warehousetigergraph__run_loading_job_with_file/tigergraph__run_loading_job_with_datatigergraph__get_loading_jobs/tigergraph__get_loading_job_statustigergraph__drop_loading_job
Statistics Operations
tigergraph__get_vertex_count/tigergraph__get_edge_counttigergraph__get_node_degree
GSQL Operations
tigergraph__gsql— Execute raw GSQLtigergraph__generate_gsql— Generate GSQL from natural language (requires[llm])tigergraph__generate_cypher— Generate openCypher from natural language (requires[llm])
Vector Schema Operations
tigergraph__add_vector_attribute/tigergraph__drop_vector_attributetigergraph__list_vector_attributes/tigergraph__get_vector_index_status
Vector Data Operations
tigergraph__upsert_vectorstigergraph__load_vectors_from_csv/tigergraph__load_vectors_from_jsontigergraph__search_top_k_similarity/tigergraph__fetch_vector
Data Source Operations
tigergraph__create_data_source/tigergraph__update_data_sourcetigergraph__get_data_source/tigergraph__drop_data_sourcetigergraph__get_all_data_sources/tigergraph__drop_all_data_sourcestigergraph__get_data_source_types— List supported types and their configuration keystigergraph__preview_sample_data
Supported data source types:
Family | Types |
Object storage |
|
Data warehouse |
|
Lakehouse |
|
Streaming |
|
Each type takes different configuration keys. Call tigergraph__get_data_source_types
for the required keys and a worked example, or see
Loading from a data warehouse.
Credentials in config are sent to TigerGraph but masked in tool responses, so they
do not appear in a conversation transcript.
Connection / Session
tigergraph__list_connections/tigergraph__show_connection— Inspect configured profilestigergraph__authenticate— Register per-session TigerGraph credentials (HTTP/SSE mode)
Discovery & Navigation
tigergraph__discover_tools— Search for tools by description or keywordstigergraph__get_workflow— Get step-by-step workflow templatestigergraph__get_tool_info— Get detailed information about a specific tool
LLM-Friendly Features
Structured Responses
Every tool returns a consistent JSON structure:
{
"success": true,
"operation": "get_node",
"summary": "Found vertex 'p123' of type 'Person'",
"data": { ... },
"suggestions": ["View connected edges: get_node_edges(...)"],
"metadata": { "graph_name": "MyGraph" }
}Error responses include actionable recovery hints:
{
"success": false,
"operation": "get_node",
"error": "Vertex not found",
"suggestions": ["Verify the vertex_id is correct"]
}Rich Tool Descriptions
Each tool includes detailed descriptions with use cases, common workflows, tips, warnings, and related tools.
Token Optimization
Responses are designed for efficient LLM token usage — no echoing of input parameters, only new information (results, counts, boolean answers).
Tool Discovery
# Find the right tool
result = await session.call_tool("tigergraph__discover_tools",
arguments={"query": "how to add data to the graph"})
# Get a workflow template
result = await session.call_tool("tigergraph__get_workflow",
arguments={"workflow_type": "data_loading"})
# Get detailed tool info
result = await session.call_tool("tigergraph__get_tool_info",
arguments={"tool_name": "tigergraph__add_node"})Notes
Transport: stdio by default
Error Detection: GSQL operations include error detection for syntax and semantic errors
Connection Management: Connections are pooled by profile and reused across requests; pool is released at server shutdown
Performance: Persistent HTTP connection pool per profile; async non-blocking I/O;
v.outdegree()for O(1) degree counting; batch operations for multiple vertices/edges
Available Tools
69 toolstigergraph__add_edgeAIdempotent
Add a single edge (relationship) to a TigerGraph graph connecting two vertices.
Use When: • Creating a relationship between two entities • Connecting vertices in the graph • Building graph structure • Adding individual relationships
Quick Start:
{
"source_vertex_type": "Person",
"source_vertex_id": "user1",
"edge_type": "FOLLOWS",
"target_vertex_type": "Person",
"target_vertex_id": "user2",
"attributes": {"since": "2024-01-15"}
}Common Workflow:
Ensure both source and target vertices exist (use 'add_node')
Call 'add_edge' to create relationship
Optionally add edge attributes (like timestamps)
Verify with 'get_neighbors' or 'get_node_edges'
Tips: • Both vertices must exist before adding edge • Edge type must match schema definition • For multiple edges, use 'add_edges' (more efficient) • Edge attributes are optional
Related Tools: add_edges, add_node, get_neighbors, delete_edge
Inputs: edge_type (required), source_vertex_id (required), target_vertex_id (required), source_vertex_type (required), +4 more.
tigergraph__add_edgesAIdempotent
Add multiple edges (relationships) to a TigerGraph graph in a single batch operation. More efficient than calling 'add_edge' multiple times.
Use When: • Loading multiple relationships • Building graph connections in bulk • Importing relationship data from files • Initial graph construction
Quick Start:
{
"edge_type": "FOLLOWS",
"edges": [
{"from_type": "Person", "from_id": "u1", "to_type": "Person", "to_id": "u2"},
{"from_type": "Person", "from_id": "u2", "to_type": "Person", "to_id": "u3"}
]
}Common Workflow:
Add all vertices first with 'add_nodes'
Use 'add_edges' to create relationships
Verify with 'get_edge_count'
Tips: • All edges in one call must be same edge type • All referenced vertices must exist • Batch size: 1000-5000 edges per call is optimal • Much faster than individual 'add_edge' calls
Related Tools: add_edge, add_nodes, get_edge_count
Inputs: edges (required), edge_type (required), profile, graph_name.
tigergraph__add_nodeAIdempotent
Add a single node (vertex) to a TigerGraph graph. This performs an upsert operation - creates a new vertex if it doesn't exist, or updates attributes if it does.
Use When: • Creating a single new entity (user, product, document, etc.) • Updating an existing vertex's attributes • You have individual entities to add (not batch loading)
Quick Start:
{
"vertex_type": "Person",
"vertex_id": "user123",
"attributes": {"name": "Alice", "age": 30}
}Common Workflow:
Call 'show_graph_details' to understand vertex types and attributes
Use 'add_node' to create individual vertices
Call 'get_node' to verify the vertex was created
Use 'add_edge' to connect this vertex to others
Tips: • For multiple vertices: Use 'add_nodes' instead (more efficient) • Primary key is required (usually the 'id' attribute) • Attribute names must match the schema exactly (case-sensitive) • This is an upsert: existing vertices are updated, not duplicated
More Examples:
// Add a product
{
"vertex_type": "Product",
"vertex_id": "prod456",
"attributes": {"name": "Laptop", "price": 999.99, "category": "Electronics"}
}
// Add a document with minimal attributes
{
"vertex_type": "Document",
"vertex_id": "doc789",
"attributes": {"title": "Report Q4 2024"}
}Related Tools: • add_nodes - Batch insert multiple vertices • get_node - Retrieve a vertex by ID • delete_node - Remove a vertex • has_node - Check if vertex exists
Inputs: vertex_id (required), vertex_type (required), profile, attributes, +1 more.
tigergraph__add_nodesAIdempotent
Add multiple nodes (vertices) to a TigerGraph graph in a single batch operation. This is significantly more efficient than calling 'add_node' multiple times.
Use When: • Loading multiple vertices of the same type • Importing data from CSV, JSON, or database • Initial data population • Bulk updates to existing vertices
Quick Start:
{
"vertex_type": "Person",
"vertices": [
{"id": "user1", "name": "Alice", "age": 30},
{"id": "user2", "name": "Bob", "age": 25}
]
}Common Workflow:
Call 'show_graph_details' to understand the schema
Prepare your data with primary keys and attributes
Use 'add_nodes' to load vertices in batches
Call 'get_vertex_count' to verify loading
Use 'add_edges' to create relationships
Tips: • Set 'vertex_id' to match your schema's primary key name (default: 'id') • For SARGraph: vertex_id='ACCOUNT_ID' for Account vertices • All vertices must be the same type • For very large datasets (>10K vertices), consider using loading jobs • Batch size: 1000-5000 vertices per call is optimal
Warning: Common Mistakes: • Missing primary key in one or more vertices • Using wrong vertex_id name (check schema with show_graph_details) • Mixing different vertex types in one call • Attribute name typos (must match schema exactly) • Wrong data types (e.g., string instead of int)
Inputs: vertices (required), vertex_type (required), profile, vertex_id, +1 more.
tigergraph__add_vector_attributeA
Add a vector attribute to an existing vertex type. Creates a schema change job to ALTER VERTEX with ADD VECTOR ATTRIBUTE.
Inputs: dimension (required), vector_name (required), vertex_type (required), metric, +2 more.
tigergraph__authenticateAIdempotent
Register TigerGraph credentials for the current MCP session.
Re-points one of the session's connections at a TigerGraph instance. Omit profile to replace the default profile's connection, or name a profile to replace only that one, leaving the session's other profiles untouched. Stdio mode uses env-var profiles instead and does not need this tool.
Either api_token/jwt_token OR username + password must be supplied. The credentials live only in the session's in-memory connection pool and are dropped on disconnect.
Inputs: host (required), secret, gs_port, profile, +9 more.
tigergraph__clear_graph_dataADestructiveIdempotent
Clear all data (vertices and edges) from a specific graph while keeping its schema structure intact. This is a destructive operation that removes all graph data.
Use When: • Resetting a graph to empty state • Clearing test data before loading production data • Starting data reload with same schema
Quick Start:
{
"graph_name": "MyGraph",
"confirm": true
}WARNING: • Deletes ALL vertices and edges in the graph • Operation is PERMANENT and cannot be undone • Must set 'confirm': true to execute • Schema (vertex/edge types) remains intact
Tips: • Preserves schema, only clears data • To delete everything including schema, use 'drop_graph' • Always backup important data first • Can specify 'vertex_type' to clear only specific type
Related Tools: drop_graph, get_vertex_count, delete_nodes
Inputs: confirm, profile, graph_name, vertex_type.
tigergraph__create_data_sourceA
Create a new data source for loading data from object storage (S3, GCS, Azure Blob), a data warehouse (Snowflake, BigQuery, PostgreSQL), an Iceberg catalog, or Kafka. Call 'get_data_source_types' first if unsure which keys a type needs; if the server rejects the request, the response includes the keys that type requires.
Inputs: config (required), data_source_name (required), data_source_type (required), profile.
tigergraph__create_graphA
Create a new graph in the TigerGraph database with its schema (vertex types and edge types). Each graph has its own independent schema.
Use When: • Creating a new graph from scratch • Setting up a graph with specific vertex and edge types • Initializing a new project or data model • Defining the structure before loading data
Quick Start:
{
"graph_name": "SocialNetwork",
"vertex_types": [
{
"name": "Person",
"primary_id": "id",
"primary_id_type": "STRING",
"attributes": [
{"name": "name", "type": "STRING"},
{"name": "age", "type": "INT"}
]
}
],
"edge_types": [
{
"name": "FOLLOWS",
"from_vertex": "Person",
"to_vertex": "Person",
"directed": true,
"attributes": [
{"name": "since", "type": "STRING"}
]
}
]
}Common Workflow:
Use 'list_graphs' to check if graph name is available
Design your vertex types and edge types
Call 'create_graph' with the schema
Use 'show_graph_details' to verify it was created correctly
Start loading data with 'add_node' and 'add_edge'
Vertex Primary Key Options:
• Default: auto-generates PRIMARY_ID id STRING with primary_id_as_attribute
• Explicit PRIMARY_ID: set primary_id (string) and primary_id_type on vertex type
• PRIMARY KEY mode: set primary_key: true on one attribute (not GraphStudio compatible)
• Composite key: set primary_id to a list of attribute names, e.g. ["title", "year"]
All listed attributes must exist in the attribute list (not GraphStudio compatible)
• The key is always queryable as a regular attribute
Tips: • Define all vertex types before edge types • Edge types reference vertex types by name • Set 'directed': false on edge types for undirected edges (default: directed) • Consider using 'get_workflow' for step-by-step guidance
Related Tools: list_graphs, show_graph_details, drop_graph
Inputs: graph_name (required), vertex_types (required), profile, edge_types.
tigergraph__create_loading_jobA
Create a loading job from structured configuration. The job defines how to load data from files into vertices and edges. Each file config specifies: file alias, separator, header, EOL, and mappings. Node mappings define which columns map to vertex attributes. Edge mappings define source/target columns and edge attributes. Optionally run the job immediately and drop it after execution.
Inputs: files (required), job_name (required), profile, run_job, +2 more.
tigergraph__delete_edgeADestructiveIdempotent
Delete a single edge (relationship) from a TigerGraph graph.
Use When: • Removing a specific relationship • Disconnecting two vertices • Graph maintenance
Quick Start:
{
"source_vertex_type": "Person",
"source_vertex_id": "user1",
"edge_type": "FOLLOWS",
"target_vertex_type": "Person",
"target_vertex_id": "user2"
}Warning: • Operation is permanent • Does not delete the vertices, only the edge
Related Tools: delete_edges, add_edge, has_edge
Inputs: edge_type (required), source_vertex_id (required), target_vertex_id (required), source_vertex_type (required), +3 more.
tigergraph__delete_edgesADestructiveIdempotent
Delete multiple edges (relationships) from a TigerGraph graph.
Use When: • Removing multiple relationships • Bulk edge deletion • Graph restructuring
Quick Start:
{
"edge_type": "FOLLOWS",
"edges": [
{"from_type": "Person", "from_id": "u1", "to_type": "Person", "to_id": "u2"},
{"from_type": "Person", "from_id": "u2", "to_type": "Person", "to_id": "u3"}
]
}Warning: • Operation is permanent and cannot be undone • Does not delete vertices
Related Tools: delete_edge, add_edges
Inputs: edges (required), edge_type (required), profile, graph_name.
tigergraph__delete_nodeADestructiveIdempotent
Purpose: Delete a single vertex (node) from the graph by its ID.
When to Use:
Remove a specific vertex from the graph
Clean up obsolete data
Delete test data
Remove entities based on business logic
Important Notes:
Warning: This operation is permanent and cannot be undone
Connected edges will also be deleted (CASCADE behavior)
Verify the vertex exists before deletion if needed
Common Workflows:
Safe delete:
has_node()→delete_node()→ verify withget_node()Bulk delete: Use
delete_nodes()with WHERE clause instead
Tips:
Use has_node() first to verify existence
Consider the impact on connected edges
For multiple deletions, use delete_nodes() for better performance
Related Tools:
delete_nodes: Delete multiple vertices at once
has_node: Check if vertex exists before deletion
get_node: Verify deletion completed
Inputs: vertex_id (required), vertex_type (required), profile, graph_name.
tigergraph__delete_nodesADestructiveIdempotent
Purpose: Delete multiple vertices (nodes) from the graph in a single operation.
When to Use:
Bulk deletion of vertices matching criteria
Delete specific set of vertices by IDs
Clear all vertices of a type
Data cleanup operations
Important Notes:
Warning: This operation is permanent and cannot be undone
Warning: Omitting WHERE will delete ALL vertices of the specified type
Connected edges will also be deleted (CASCADE behavior)
More efficient than multiple delete_node() calls
Usage Modes:
By WHERE clause:
delete_nodes(vertex_type='Person', where='age > 70')By ID list:
delete_nodes(vertex_type='Person', vertex_ids=['id1', 'id2'])Delete all:
delete_nodes(vertex_type='TempData')(no where/ids)
Safety Tips:
ALWAYS test WHERE clause with get_nodes() first
Use get_vertex_count() to verify expected deletion count
Consider backing up data before bulk deletions
Related Tools:
delete_node: Delete a single vertex
get_nodes: Preview vertices before deletion
get_vertex_count: Check deletion impact
Inputs: vertex_type (required), where, profile, graph_name, +1 more.
tigergraph__discover_toolsARead-onlyIdempotent
Discover which TigerGraph tools are relevant for your task.
Use this tool when:
You're unsure which tool to use for your goal
You want to explore available capabilities
You need suggestions for accomplishing a task
Returns:
List of recommended tools with descriptions
Use cases and complexity ratings
Prerequisites and related tools
Example parameters
Example: task_description: 'I want to add multiple users to the graph'
Inputs: task_description (required), limit, category.
tigergraph__drop_all_data_sourcesADestructiveIdempotent
Drop all data sources. WARNING: This is a destructive operation.
Inputs: confirm, profile.
tigergraph__drop_data_sourceADestructiveIdempotent
Drop (delete) a data source.
Inputs: data_source_name (required), profile, graph_name.
tigergraph__drop_graphADestructiveIdempotent
Drop (delete) a graph and its schema from the TigerGraph database. This permanently removes the graph, its schema, and all data.
Use When: • Removing a graph that's no longer needed • Cleaning up test graphs • Starting fresh with a new schema
Quick Start:
{
"graph_name": "TestGraph"
}Warning: DANGER: • This deletes EVERYTHING: schema, vertices, edges, queries, loading jobs • Operation is PERMANENT and cannot be undone • Double-check the graph_name before executing • Consider using 'clear_graph_data' if you only want to remove data
Tips: • Use 'list_graphs' first to confirm the graph name • For production graphs, always backup first • To keep schema but clear data, use 'clear_graph_data'
Related Tools: create_graph, clear_graph_data, list_graphs
Inputs: graph_name (required), profile.
tigergraph__drop_loading_jobBDestructiveIdempotent
Drop (delete) a loading job from the graph.
Inputs: job_name (required), profile, graph_name.
tigergraph__drop_queryADestructiveIdempotent
Drop (delete) an installed query from TigerGraph.
Use When: • Removing queries no longer needed • Cleaning up test queries • Before re-installing a modified query
Quick Start:
{
"query_name": "oldQuery"
}Warning: • Permanently deletes the installed query • Cannot be undone • Any code calling this query will fail
Tips: • Use 'show_query' first to review before dropping • Cannot drop queries being used by other queries
Related Tools: install_query, show_query, is_query_installed
Inputs: query_name (required), profile, graph_name.
tigergraph__drop_vector_attributeADestructiveIdempotent
Drop a vector attribute from a vertex type. Creates a schema change job to ALTER VERTEX with DROP VECTOR ATTRIBUTE.
Inputs: vector_name (required), vertex_type (required), profile, graph_name.
tigergraph__fetch_vectorARead-onlyIdempotent
Fetch vertices with their vector data using GSQL PRINT WITH VECTOR. Note: Vector attributes cannot be fetched via REST API.
Inputs: vertex_ids (required), vertex_type (required), profile, graph_name, +1 more.
tigergraph__generate_cypherARead-onlyIdempotent
Generate an openCypher query from a natural language description using an LLM. Use this tool when you prefer Cypher syntax over GSQL. The generated query will be wrapped in TigerGraph's INTERPRET OPENCYPHER QUERY format. graph_name is required as the query needs to specify the target graph. Configure the LLM via env vars: LLM_MODEL (e.g., 'gpt-4o' or 'openai:gpt-4o') and optionally LLM_PROVIDER.
Inputs: graph_name (required), query_description (required), profile.
tigergraph__generate_gsqlARead-onlyIdempotent
Generate a GSQL query from a natural language description using an LLM. Use this tool when you need to create a GSQL query but are unsure of the exact syntax. The generated query can then be executed using the gsql tool. For best results, provide the graph_name so the schema can be used to generate accurate queries. Configure the LLM via env vars: LLM_MODEL (e.g., 'gpt-4o' or 'openai:gpt-4o') and optionally LLM_PROVIDER.
Inputs: query_description (required), profile, graph_name.
tigergraph__get_all_data_sourcesBRead-onlyIdempotent
Get information about all data sources.
Inputs: profile.
tigergraph__get_data_sourceBRead-onlyIdempotent
Get information about a specific data source.
Inputs: data_source_name (required), profile.
tigergraph__get_data_source_typesARead-onlyIdempotent
List the data source types supported by 'create_data_source', with the required and optional configuration keys and an example config for each. Answers locally without contacting TigerGraph.
Inputs: family.
tigergraph__get_edgeARead-onlyIdempotent
Get a single edge (relationship) from a TigerGraph graph by specifying source, target, and edge type.
Use When: • Retrieving a specific relationship • Checking edge attributes • Verifying edge was created
Quick Start:
{
"source_vertex_type": "Person",
"source_vertex_id": "user1",
"edge_type": "FOLLOWS",
"target_vertex_type": "Person",
"target_vertex_id": "user2"
}Tips: • Requires full edge specification (source, target, type) • Returns edge attributes if any • Use 'get_neighbors' for simpler neighbor queries
Related Tools: get_edges, has_edge, get_neighbors
Inputs: edge_type (required), source_vertex_id (required), target_vertex_id (required), source_vertex_type (required), +3 more.
tigergraph__get_edge_countBRead-onlyIdempotent
Get the count of edges in a TigerGraph graph.
Inputs: profile, edge_type, graph_name.
tigergraph__get_edgesARead-onlyIdempotent
Get multiple edges (relationships) from a TigerGraph graph, optionally filtered by type.
Use When: • Retrieving multiple edges • Exploring graph relationships • Data export and analysis
Quick Start:
{
"source_vertex_type": "Person",
"source_vertex_id": "user1",
"edge_type": "FOLLOWS"
}Tips: • Can filter by edge type • Returns all edges from a source vertex • Use 'get_neighbors' for simpler use cases
Related Tools: get_edge, get_neighbors, get_edge_count
Inputs: limit, profile, edge_type, graph_name, +2 more.
tigergraph__get_global_schemaARead-onlyIdempotent
Get the complete global schema including all global vertex types, edge types, graphs, and their member types. Runs GSQL 'LS' command.
Use When: • You need to see all graphs and their schemas at once • Understanding the complete database structure • Finding all available vertex and edge types across all graphs • Database-level schema exploration
Quick Start:
{}(No parameters needed)
Tips: • Returns output from GSQL 'LS' command • Shows all graphs in the database • For single graph details, use 'show_graph_details' instead • Useful for database administrators
Related Tools: list_graphs, show_graph_details, get_graph_schema
Inputs: profile.
tigergraph__get_graph_schemaARead-onlyIdempotent
Get the schema of a specific graph — vertex types, edge types, and their attributes — as structured JSON. Returns schema only, not queries or jobs.
Use When: • You need to know vertex/edge types and their attributes • Building or validating queries against the schema • Programmatic schema inspection or comparison
Quick Start:
{
"graph_name": "SocialNetwork"
}Tips: • Returns structured JSON (vertex types, edge types, attributes) • For a full listing including queries and jobs, use 'show_graph_details' • For just graph names, use 'list_graphs'
Related Tools: show_graph_details (full listing), list_graphs (names only)
Inputs: profile, graph_name.
tigergraph__get_loading_jobsARead-onlyIdempotent
Get a list of all loading jobs defined for the current graph.
Inputs: profile, graph_name.
tigergraph__get_loading_job_statusBRead-onlyIdempotent
Get the status of a specific loading job by its job ID.
Inputs: job_id (required), profile, graph_name.
tigergraph__get_neighborsARead-onlyIdempotent
Get neighbor vertices connected to a source vertex via edges. Useful for 1-hop graph traversal to find connected entities.
Use When: • Finding vertices directly connected to a vertex • 1-hop traversal (immediate neighbors) • Discovering relationships • Building recommendation lists
Quick Start:
{
"vertex_type": "Person",
"vertex_id": "user123",
"edge_type": "FOLLOWS"
}Common Workflow:
Have a source vertex ID
Call 'get_neighbors' with vertex info
Optionally filter by edge type
Receive list of connected vertices
Tips: • Simpler than writing a query for 1-hop traversal • Can filter by edge type (e.g., only 'FOLLOWS' edges) • Can specify target vertex type • For multi-hop traversal, use 'run_query' instead
Examples: • Find friends: edge_type='FRIENDS' • Find purchases: edge_type='PURCHASED', target_vertex_type='Product' • Find all connections: omit edge_type
Related Tools: get_node_edges, run_query, add_edge
Inputs: vertex_id (required), vertex_type (required), limit, profile, +3 more.
tigergraph__get_nodeARead-onlyIdempotent
Get a single node (vertex) from a TigerGraph graph by its type and ID.
Use When: • Retrieving a specific entity by its ID • Verifying a vertex was created successfully • Checking current attribute values • Fetching details before updating
Quick Start:
{
"vertex_type": "Person",
"vertex_id": "user123"
}Related Tools: • get_nodes - Get multiple vertices • has_node - Check if vertex exists • get_node_edges - Get edges connected to vertex
Inputs: vertex_id (required), vertex_type (required), profile, graph_name.
tigergraph__get_node_degreeBRead-onlyIdempotent
Get the degree (number of connected edges) of a node in a TigerGraph graph.
Inputs: vertex_id (required), vertex_type (required), profile, direction, +2 more.
tigergraph__get_node_edgesARead-onlyIdempotent
Purpose: Retrieve all edges connected to a specific vertex (node).
When to Use:
Explore connections from a vertex
Find relationships of a specific type
Analyze node connectivity patterns
Get edge attributes and target vertices
What You Get:
Edge type and ID
Edge attributes
Target vertex information
Edge direction (outgoing from the specified vertex)
Common Workflows:
Explore all connections:
get_node_edges(vertex_type='Person', vertex_id='123')Specific relationship type:
get_node_edges(..., edge_type='FRIEND_OF')Degree analysis: Count returned edges to get outgoing degree
Tips:
Returns OUTGOING edges only (edges starting from this vertex)
Use get_node_degree() for quick connection count
Use get_neighbors() to get target vertices without edge details
Combine with pagination (limit) for highly connected vertices
Note: This returns edges where the specified vertex is the SOURCE. For incoming edges, use a reverse traversal query or get_neighbors().
Related Tools:
get_node_degree: Count connections without retrieving edges
get_neighbors: Get connected vertices
get_edges: Query edges by type across the graph
Inputs: vertex_id (required), vertex_type (required), limit, profile, +2 more.
tigergraph__get_nodesARead-onlyIdempotent
Purpose: Retrieve multiple vertices (nodes) from the graph with optional filtering and sorting.
When to Use:
List vertices of a specific type
Search for vertices matching certain criteria
Browse graph data with pagination
Find vertices based on attribute values
Key Features:
WHERE clause for filtering
Sorting by attributes (ascending/descending)
Limit results for pagination
Returns complete vertex data including all attributes
Common Workflows:
List all vertices:
get_nodes(vertex_type='Person', limit=10)Filter by attribute:
get_nodes(vertex_type='Person', where='age > 25')Sort results:
get_nodes(vertex_type='Person', sort='-created_at', limit=20)
Tips:
Use limit to avoid retrieving too many vertices
WHERE clause syntax follows TigerGraph conventions
Sort with '-' prefix for descending order
Combine where, sort, and limit for precise queries
Related Tools:
get_node: Get a single specific vertex
get_vertex_count: Count vertices before retrieving
run_query: For complex multi-hop queries
Inputs: vertex_type (required), sort, limit, where, +2 more.
tigergraph__get_query_descriptionARead-onlyIdempotent
Get the description and parameter descriptions of one or more installed queries. Requires TigerGraph 4.0+.
Use When: • Discovering what a query does and what each parameter means • Building query documentation • Understanding a query's parameters together with their descriptions
Quick Start:
{
"query_name": "getPersonFriends"
}Tips: • Pass 'all' (the default) to read descriptions for every query • Pair with 'get_query_metadata' to combine parameter types and descriptions • Set descriptions with 'update_query_description'
Related Tools: update_query_description, get_query_metadata, show_query
Inputs: profile, graph_name, query_name.
tigergraph__get_query_metadataARead-onlyIdempotent
Get metadata about an installed query including parameters, return type, and other details.
Use When: • Understanding query parameters and signature • Discovering what queries are available • Building query documentation • Programmatic query discovery
Quick Start:
{
"query_name": "getPersonFriends"
}Tips: • Shows query parameters, types, and metadata • Helps understand how to call the query • Use 'show_query' to see the actual query text
Related Tools: show_query, is_query_installed, run_installed_query
Inputs: query_name (required), profile, graph_name.
tigergraph__get_tool_infoARead-onlyIdempotent
Get detailed information about a specific TigerGraph tool.
Use this tool when:
You want to understand a tool's capabilities
You need examples of how to use a tool
You want to know prerequisites or related tools
Returns:
Detailed tool description
Use cases and examples
Prerequisites and related tools
Common next steps
Inputs: tool_name (required).
tigergraph__get_vector_index_statusARead-onlyIdempotent
Check the rebuild status of vector indexes. Returns 'Ready_for_query' when complete or 'Rebuild_processing' if still building.
Inputs: profile, graph_name, vector_name, vertex_type.
tigergraph__get_vertex_countARead-onlyIdempotent
Get the count of vertices in a TigerGraph graph.
Inputs: profile, graph_name, vertex_type.
tigergraph__get_workflowARead-onlyIdempotent
Get a step-by-step workflow template for common TigerGraph tasks.
Use this tool when:
You need to complete a complex multi-step task
You want to follow best practices
You're new to TigerGraph and need guidance
Returns:
Ordered list of tools to use
Example parameters for each step
Explanations of what each step accomplishes
Available workflows: create_graph, load_data, query_data, vector_search, graph_analysis, setup_connection
Inputs: workflow_type (required).
tigergraph__gsqlADestructive
Execute a GSQL command on TigerGraph. Use this for administrative tasks (e.g., creating users, granting roles) or schema modifications (e.g., CREATE VERTEX). Do NOT use this for running data queries (SELECT statements) - use run_query instead. Example: CREATE USER alice WITH PASSWORD 'password' or LS.
Inputs: command (required), profile, graph_name.
tigergraph__has_edgeARead-onlyIdempotent
Check if an edge (relationship) exists between two vertices without retrieving its data.
Use When: • Verifying relationship existence • Validation logic • More efficient than get_edge when you only need existence check
Quick Start:
{
"source_vertex_type": "Person",
"source_vertex_id": "user1",
"edge_type": "FOLLOWS",
"target_vertex_type": "Person",
"target_vertex_id": "user2"
}Tips: • Returns boolean (true/false) • Faster than get_edge when you don't need the data • Use before add_edge to avoid duplicates
Related Tools: get_edge, add_edge
Inputs: edge_type (required), source_vertex_id (required), target_vertex_id (required), source_vertex_type (required), +3 more.
tigergraph__has_nodeARead-onlyIdempotent
Purpose: Check if a vertex (node) exists in the graph without retrieving its full data.
When to Use:
Verify a vertex exists before operations
Validation in data pipelines
Conditional logic based on vertex existence
Lightweight existence checks (faster than get_node)
Key Features:
Returns simple boolean result (exists: true/false)
More efficient than get_node() for existence checks
No data transfer overhead
Common Workflows:
Safe operations:
has_node()→ if true, proceed with get_node()/delete_node()Validation: Check required vertices exist before adding edges
Conditional creation: If not exists, create with add_node()
Tips:
Use this instead of get_node() when you only need existence confirmation
Combine with add_node() for upsert logic
Faster than catching errors from get_node()
Related Tools:
get_node: Retrieve full vertex data if it exists
add_node: Create vertex if it doesn't exist
delete_node: Remove vertex after confirming existence
Inputs: vertex_id (required), vertex_type (required), profile, graph_name.
tigergraph__install_queryA
Install a GSQL query on a TigerGraph graph, compiling it for faster repeated execution.
Use When: • You have a query you'll run multiple times • You want better query performance • Creating reusable query logic • Building query libraries
Quick Start:
{
"query_text": "CREATE QUERY getPersonFriends(VERTEX<Person> p) FOR GRAPH MyGraph { ... }"
}Common Workflow:
Write and test query with 'run_query' first
Once working, install with 'install_query'
Run with 'run_installed_query' (faster)
Tips: • Query text should start with 'CREATE QUERY' • Installation compiles the query for better performance • Can define parameters in query signature • Use 'show_query' to view installed query text
Related Tools: run_installed_query, drop_query, show_query
Inputs: query_text (required), profile, graph_name.
tigergraph__is_query_installedARead-onlyIdempotent
Check if a query is installed in TigerGraph without running it.
Use When: • Verifying query installation • Before trying to run an installed query • Conditional query logic
Quick Start:
{
"query_name": "getPersonFriends"
}Tips: • Returns true/false • Faster than trying to run and catching errors • Use before 'run_installed_query'
Related Tools: install_query, run_installed_query, show_query
Inputs: query_name (required), profile, graph_name.
tigergraph__list_connectionsARead-onlyIdempotent
List all available TigerGraph connection profiles. Profiles are configured via environment variables: the default profile uses TG_HOST, TG_USERNAME, etc., while named profiles use _TG_HOST, _TG_USERNAME, etc.
Inputs: no named parameters.
tigergraph__list_graphsARead-onlyIdempotent
List all graph names in the TigerGraph database. Returns only graph names — no schema, query, or job details.
Use When: • Discovering what graphs exist in the database • First step when connecting to a new TigerGraph instance • Verifying a graph was created or dropped successfully
Quick Start:
{}(No parameters needed)
Next Steps: • Use 'show_graph_details' to see everything under a graph (schema, queries, jobs) • Use 'get_graph_schema' to get just the schema (vertex/edge types)
Related Tools: show_graph_details, get_graph_schema, create_graph
Inputs: profile.
tigergraph__list_vector_attributesARead-onlyIdempotent
Get vector attribute information (name, dimension, metric) for vertex types in a graph. Parses the output of the GSQL 'LS' command. Optionally filter by vertex type.
Related Tools: add_vector_attribute, drop_vector_attribute, get_vector_index_status
Inputs: profile, graph_name, vertex_type.
tigergraph__load_vectors_from_csvA
Bulk-load vectors from a CSV/delimited file into a vertex type's vector attribute. Creates a GSQL loading job, runs it with the file, then drops the job.
File format: Each row has a vertex ID and a vector. Fields are separated by field_separator (default |). Vector elements are separated by element_separator (default ,).
Example file (field_separator='|', element_separator=','):
vertex1|0.1,0.2,0.3
vertex2|0.4,0.5,0.6Prerequisites:
Vertex type must already exist
Vector attribute must already be added (use 'add_vector_attribute')
File must exist on the local machine (it is uploaded to TigerGraph via REST)
Related Tools: add_vector_attribute, load_vectors_from_json (JSON Lines alternative), upsert_vectors (REST API for in-memory data), get_vector_index_status (check indexing after load)
Inputs: file_path (required), vertex_type (required), vector_attribute (required), header, +6 more.
tigergraph__load_vectors_from_jsonA
Bulk-load vectors from a JSON Lines (.jsonl) file into a vertex type's vector attribute. Creates a GSQL loading job with JSON_FILE="true", runs it with the file, then drops the job.
File format: Each line is a JSON object with an ID field and a vector field. The vector is stored as a comma-separated string (not a JSON array).
Example file (id_key='id', vector_key='embedding'):
{"id": "vertex1", "embedding": "0.1,0.2,0.3"}
{"id": "vertex2", "embedding": "0.4,0.5,0.6"}Prerequisites:
Vertex type must already exist
Vector attribute must already be added (use 'add_vector_attribute')
File must exist on the local machine (it is uploaded to TigerGraph via REST)
Related Tools: add_vector_attribute, load_vectors_from_csv (CSV alternative), upsert_vectors (REST API for in-memory data), get_vector_index_status (check indexing after load)
Inputs: file_path (required), vertex_type (required), vector_attribute (required), id_key, +4 more.
tigergraph__preview_sample_dataBRead-onlyIdempotent
Preview sample data from a file in a data source.
Inputs: file_path (required), data_source_name (required), profile, num_rows, +1 more.
tigergraph__run_installed_queryADestructive
Run an installed GSQL query on a TigerGraph graph with parameters. Faster than interpreted queries for repeated execution.
Use When: • Running pre-installed, compiled queries • Queries that are executed frequently • Performance-critical operations • Parameterized queries with different inputs
Quick Start:
{
"query_name": "getPersonFriends",
"params": {"personId": "user123", "maxHops": 2}
}Common Workflow:
Install query once with 'install_query'
Run multiple times with 'run_installed_query' and different params
Much faster than 'run_query' for repeated use
Tips: • Queries must be installed first with 'install_query' • Use 'is_query_installed' to check if query exists • Provide params as dictionary matching query signature • Faster than interpreted queries
Related Tools: install_query, is_query_installed, show_query
Inputs: query_name (required), params, profile, graph_name.
tigergraph__run_loading_job_with_dataB
Execute a loading job with inline data string. The data is posted to TigerGraph and loaded according to the specified loading job definition.
Inputs: data (required), file_tag (required), job_name (required), eol, +5 more.
tigergraph__run_loading_job_with_fileC
Execute a loading job with a data file. The file is uploaded to TigerGraph and loaded according to the specified loading job definition.
Inputs: file_tag (required), job_name (required), file_path (required), eol, +5 more.
tigergraph__run_queryADestructive
Run an interpreted query on a TigerGraph graph. Supports both GSQL and openCypher query languages. Use this for ad-hoc queries without needing to install them first.
Use When: • Running one-time or ad-hoc queries • Testing queries before installation • Simple data retrieval operations • Prototyping and exploration
Quick Start (GSQL):
{
"query_text": "INTERPRET QUERY () FOR GRAPH MyGraph { SELECT v FROM Person:v LIMIT 5; PRINT v; }"
}Quick Start (Cypher):
{
"query_text": "INTERPRET OPENCYPHER QUERY () FOR GRAPH MyGraph { MATCH (n:Person) RETURN n LIMIT 5 }"
}Common Workflow:
Call 'show_graph_details' to understand the schema
Write your query using vertex/edge types from schema
Run with 'run_query' to test
For repeated use, install with 'install_query'
Tips: • Query type auto-detected (GSQL vs Cypher) • For frequent queries, use 'install_query' + 'run_installed_query' for better performance • Always include 'FOR GRAPH' clause • Use LIMIT to avoid retrieving too much data
Warning: Syntax Notes:
• GSQL: INTERPRET QUERY () FOR GRAPH <name> { <statements> }
• Cypher: INTERPRET OPENCYPHER QUERY () FOR GRAPH <name> { <cypher> }
Related Tools: run_installed_query, install_query, get_neighbors
Inputs: query_text (required), profile, graph_name.
tigergraph__search_top_k_similarityARead-onlyIdempotent
Perform vector similarity search using TigerGraph's vectorSearch() function. Returns top-K most similar vertices with distance scores.
IMPORTANT: The query_vector dimensions MUST match the dimension defined in the vector attribute (e.g., if the attribute was created with DIMENSION=1536, the query vector must have exactly 1536 elements). A dimension mismatch will cause the search to fail or return incorrect results.
Use list_vector_attributes to check the expected dimension before searching.
Related Tools: list_vector_attributes (check dimension), fetch_vector (retrieve vector values), get_vector_index_status (check index readiness)
Inputs: vertex_type (required), query_vector (required), vector_attribute (required), ef, +4 more.
tigergraph__show_connectionARead-onlyIdempotent
Show non-sensitive connection details for a specific profile (host, username, graph name, ports). Never reveals passwords or tokens.
Inputs: profile.
tigergraph__show_graph_detailsARead-onlyIdempotent
Show details of a specific graph. By default shows everything (schema, queries, loading jobs, data sources). Use 'detail_type' to show only a specific category.
Use When: • You need a full picture of a graph (schema + queries + jobs) • Starting work with a graph (call this first!) • Checking which queries or loading jobs are installed • Debugging schema or job issues
Quick Start:
{ "graph_name": "SocialNetwork" }(Shows everything under the graph)
Filter by category:
{ "graph_name": "SocialNetwork", "detail_type": "query" }Options: 'schema', 'query', 'loading_job', 'data_source'
Tips:
• No detail_type → shows all (GSQL LS output)
• For structured JSON schema, use 'get_graph_schema' instead
• For just graph names, use 'list_graphs'
• For vector attributes, use 'list_vector_attributes' instead
Related Tools: get_graph_schema (schema JSON), list_graphs (names only), list_vector_attributes (vector attribute details)
Inputs: profile, graph_name, detail_type.
tigergraph__show_queryARead-onlyIdempotent
Show the GSQL text of an installed query.
Use When: • Reviewing what an installed query does • Debugging query behavior • Understanding existing queries • Documenting installed queries
Quick Start:
{
"query_name": "getPersonFriends"
}Tips: • Returns the full GSQL query text • Query must be installed first • Use 'is_query_installed' to check existence
Related Tools: install_query, get_query_metadata, is_query_installed
Inputs: query_name (required), profile, graph_name.
tigergraph__update_data_sourceCIdempotent
Update an existing data source configuration.
Inputs: config (required), data_source_name (required), profile, data_source_type.
tigergraph__update_query_descriptionAIdempotent
Set a human-readable description for an installed query and, optionally, descriptions for each of its parameters. Requires TigerGraph 4.0+.
Use When: • Documenting what an installed query does and what its parameters mean • Making queries self-describing for agents and other consumers
Quick Start:
{
"query_name": "getPersonFriends",
"query_description": "Return the friends of a given person.",
"parameter_descriptions": {"personId": "ID of the person to look up"}
}Tips: • Query must be installed first • Omit 'parameter_descriptions' to set only the query-level description • Read it back with 'get_query_description'
Related Tools: get_query_description, get_query_metadata, show_query
Inputs: query_name (required), query_description (required), profile, graph_name, +1 more.
tigergraph__update_schemaADestructive
Apply incremental schema changes: add/drop vertex types, edge types, or individual attributes. Supports both local (graph-scoped) and global schema changes.
Use When:
Adding new vertex or edge types to an existing graph (local)
Creating global vertex/edge types shared across graphs (global)
Dropping vertex or edge types that are no longer needed
Adding or removing attributes on existing vertex types
Local schema change (add a vertex type to a graph):
{
"graph_name": "MyGraph",
"add_vertex_types": [{"name": "Product", "attributes": [{"name": "price", "type": "FLOAT"}]}]
}Global schema change (omit graph_name):
{
"add_vertex_types": [{"name": "SharedVertex", "attributes": [{"name": "val", "type": "INT"}]}]
}Tips:
Drop edges referencing a vertex type before dropping the vertex type
Adding attributes with defaults avoids null values on existing data
Use 'get_graph_schema' to inspect the current schema first
Omit 'graph_name' to apply changes at the global level
Related Tools: create_graph, get_graph_schema, show_graph_details
Inputs: profile, graph_name, add_edge_types, drop_edge_types, +4 more.
tigergraph__upsert_vectorsAIdempotent
Upsert multiple vertices with vector data using the REST Upsert API. Vectors must be provided inline as lists of floats (i.e., already in memory). To bulk-load vectors from a local file, use 'load_vectors_from_csv' or 'load_vectors_from_json' instead.
Inputs: vectors (required), vertex_type (required), vector_attribute (required), profile, +1 more.
tigergraph__validate_schema_namesARead-onlyIdempotent
Validate vertex type names, edge type names, attribute names, and the graph name against GSQL reserved keywords and naming conflict rules.
Use When:
Before calling 'create_graph' to catch naming problems early
Checking if user-supplied names conflict with GSQL keywords
Validating that vertex/edge type names don't collide with their attribute names
Quick Start:
{
"graph_name": "MyGraph",
"vertex_types": [
{"name": "SELECT", "attributes": [{"name": "count", "type": "INT"}]}
]
}(Returns warnings for 'SELECT' and 'count' as reserved keywords)
Related Tools: create_graph, get_graph_schema
Inputs: edge_types, graph_name, vertex_types.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 69 tools
Most tools have clearly distinct purposes, with singular/plural pairs (add_node/add_nodes, get_edge/get_edges) and lifecycle operations well separated. However, get_edges and get_node_edges overlap heavily—both retrieve edges from a source vertex—and the schema trio (get_global_schema, get_graph_schema, show_graph_details) requires careful reading to distinguish.
All tool names follow a consistent snake_case verb_noun pattern (add_node, get_edges, drop_query, list_graphs). Even meta tools like discover_tools and get_workflow fit the pattern. There is no mixing of conventions or vague generic verbs.
69 tools is an extreme count, well above the 50+ threshold for over-fragmentation. Even though TigerGraph is a complex platform, the tool surface is bloated with many near-duplicate variants (singular/plural pairs, multiple vector loading methods) that will overwhelm agents and make selection harder.
The surface is remarkably comprehensive, covering schema management, node/edge CRUD, query lifecycle (interpreted, installed, described), loading jobs, data sources, vector search, and admin via gsql. Minor gaps exist, such as a dedicated list_queries tool or conditional bulk edge deletion, but agents can work around these with show_graph_details or gsql.
Maintenance
Related MCP Connectors
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
MCP server for OnceAsk, the AI-native current-address layer for people and agents.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Related MCP Servers
- AlicenseBqualityDmaintenanceA Model Context Protocol server implementation that enables LLMs to interact with NebulaGraph database for graph exploration, supporting schema understanding, queries, and graph algorithms.529Apache 2.0

Memgraph MCP Serverofficial
AlicenseCqualityNot gradedmaintenanceA lightweight server implementation of the Model Context Protocol that connects Memgraph database with LLMs, allowing users to interact with graph databases through natural language.125MIT- AlicenseNot gradedqualityDmaintenanceA robust, lightweight Model Context Protocol (MCP) server designed to empower your AI Agents with context-awareness, safe execution sandboxes, and dedicated thought logs.ISC
- AlicenseNot gradedqualityFmaintenanceAgent-first knowledge graph MCP server that provides 25 tools for managing a knowledge graph with nodes and edges, plus a human-readable dashboard for LLMs and AI agents.276 npmApache 2.0