Plug the dataset into your agent

The whole ontology is served over MCP, so a model can trace a mechanic to its root instead of guessing from whatever it absorbed in training. No key, no account, no rate limit.

Endpoint · streamable http

https://genome-of-games.vercel.app/api/mcp/

Claude Code

Terminal

claude mcp add --transport http --scope user genome-of-games https://genome-of-games.vercel.app/api/mcp/

Then ask it something like "trace battle royale back to its root using the genome server". Drop --scope user to add it to the current project only.

Claude Desktop and claude.ai

Settings → Connectors → Add custom connector, and paste the endpoint above. Claude Desktop can also read it from its config file:

claude_desktop_config.json

{
  "mcpServers": {
    "genome-of-games": {
      "type": "http",
      "url": "https://genome-of-games.vercel.app/api/mcp/"
    }
  }
}

Cursor, VS Code, Windsurf, Zed

All of them read the same shape. Cursor uses .cursor/mcp.json, VS Code uses .vscode/mcp.json with a servers key instead of mcpServers.

mcp.json

{
  "mcpServers": {
    "genome-of-games": {
      "url": "https://genome-of-games.vercel.app/api/mcp/"
    }
  }
}

Any language

It is JSON-RPC 2.0 over POST. There is nothing to install — these all work against the raw endpoint.

bash · curl

curl -s https://genome-of-games.vercel.app/api/mcp/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "genome_trace_lineage",
      "arguments": { "mechanic": "battle royale" }
    }
  }'

python

import urllib.request, json

ENDPOINT = "https://genome-of-games.vercel.app/api/mcp/"

def genome(tool, **args):
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {"name": tool, "arguments": args},
    }
    req = urllib.request.Request(
        ENDPOINT,
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req) as r:
        result = json.load(r)["result"]
    return result["content"][0]["text"]

print(genome("genome_trace_lineage", mechanic="battle royale"))
print(genome("genome_get_studio", studio="Valve"))

node

const ENDPOINT = "https://genome-of-games.vercel.app/api/mcp/";

async function genome(tool, args = {}) {
  const res = await fetch(ENDPOINT, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "tools/call",
      params: { name: tool, arguments: args },
    }),
  });
  const { result } = await res.json();
  return result.content[0].text;
}

console.log(await genome("genome_trace_lineage", { mechanic: "battle royale" }));

typescript · official SDK

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(
  new StreamableHTTPClientTransport(new URL("https://genome-of-games.vercel.app/api/mcp/")),
);

const { tools } = await client.listTools();
const out = await client.callTool({
  name: "genome_trace_lineage",
  arguments: { mechanic: "battle royale" },
});

The eight tools

Tool	What it returns
`genome_get_overview`	Counts, families, eras, what "origin" means and where the data is weak. Start here.
`genome_search`	Find mechanics, games or studios by partial name.
`genome_get_mechanic`	Full record: origin, essay, parents, children, everything downstream, adopters.
`genome_get_game`	What a game introduced and what it inherited.
`genome_get_studio`	Titles, credited firsts and corporate lineage.
`genome_trace_lineage`	Walk a mechanic back to a root, or forward through its descendants.
`genome_list_family`	Every mechanic in one of the fifteen families.
`genome_by_year`	What was first shipped in a year or range.

Every tool returns readable prose and a structuredContent object, so agents can either quote it or parse it.

What you get back

One call, so you can see the shape before wiring anything:

genome_trace_lineage · mechanic: "battle royale"

Shrinking-Circle Battle Royale (2017) traced back 7 steps to a root:
01. Object Collision As Verb (1962) — introduced in Spacewar!
02. Single-Screen Arena (1972) — introduced in Pong
03. Same-Screen Two-Player (1972) — introduced in Pong
04. Networked Deathmatch (1993) — introduced in Doom
05. Internet Client-Server Play (1996) — introduced in Quake
06. Automated Skill Matchmaking (2004) — introduced in Halo 2
07. Shrinking-Circle Battle Royale (2017) — introduced in PUBG: Battlegrounds

Note: Shrinking-Circle Battle Royale has 2 direct parents — Automated Skill
Matchmaking (2004), Survival Needs Clock (1980). The chain above follows the
longest single path, so the other parent is not shown in it.

Terms

Free, unauthenticated and unmetered — be reasonable and it stays that way. Data is CC BY 4.0: reuse it anywhere, including commercially, as long as you attribute The Genome of Games with a link. Origins here are contested by design; read the methodology before presenting any of it as settled, and pass the caveats through to your users — genome_get_overview returns them for exactly that reason.