MCP for Google Knowledge Graph and Wikidata: Tool-by-Tool Overview

The most useful knowledge tools for language-model workflows do not try to do everything. They put boundaries around retrieval, show their work, and leave room for uncertainty. That is exactly why the open-source project commonly referenced as the Wikidata + Google Knowledge Graph MCP is worth a close look.

Published on Smithery as revanalex/wikidata-google-knowledge-mcp on September 30, 2026, and released under the MIT license, this server and CLI sits in a practical middle ground. It is not a giant semantic web platform and it is not a vague connector that sprays back dozens of loosely related hits. Its documented purpose is narrower and, in practice, more useful: let AI agents search Wikidata, read selected facts, and link local records to Wikidata QIDs with inspectable evidence and explicit uncertainty when evidence is insufficient.

That framing matters. In entity resolution work, especially inside coding tools and agent environments, the hardest failures usually come from overconfidence. A model sees a familiar name, grabs the first matching entity, then quietly builds downstream analysis on top of a bad identity link. A tool that can say “hold, this is ambiguous” is often more valuable than one that returns a slick but unverifiable answer.

The project is designed to run in MCP clients such as Claude Code, Cursor, and Codex. Wikidata access does not require an account or API key. The Google Knowledge Graph Search API is optional. That optionality is another sensible design choice because many workflows need Wikidata lookups every day, while Google cross-checking is only useful in some cases.

What this MCP actually is, and what it is not

There is a tendency in this area to blur together several different ideas: an MCP interface, Wikidata itself, the broader Wikidata MCP ecosystem, and Google’s knowledge graph APIs. This project is much more specific than that.

At its core, it is a read-only MCP server and CLI focused on entity search, fact retrieval, and identity resolution. It does not edit Wikidata. It does not edit Google. It does not touch user data. It is also explicit that it is not official Wikimedia or Google software, and it is not an export of the Google Knowledge Graph. Those disclaimers are not boilerplate. They set the right expectation for how to treat outputs from the tool.

For teams already familiar with the broader MCP for Wikidata landscape, that distinction helps. Wikidata’s own documentation describes the Wikidata MCP as a standardized way for LLMs to explore and query Wikidata programmatically through the Wikidata API and Wikidata Query Service. This project fits within that broader use case, but it is more opinionated. It narrows the interaction model around a small set of tools and emphasizes evidence-bearing resolution rather than free-form graph exploration.

That makes it especially relevant when people search for terms like MCP for google knowledge graph and wikidata, MCP for wikidata, or MCP for google knowledge graph. They are often not looking for a full semantic stack. They want to know which tool helps a model identify the right entity, inspect just the needed facts, and stop short when certainty is not justified.

Why the bounded-search design is more important than it sounds

One of the most telling implementation choices in the documented behavior is the bounded search strategy. By default, the server returns three candidates, with a maximum of five, rather than dumping a large raw result set.

That may look restrictive if you come from traditional search tooling, but in agent workflows it is usually a strength. Large candidate pools invite sloppy ranking and lazy reasoning. A model will often seize on the most recognizable label in a long list and move on. A bounded set forces a more disciplined comparison. It keeps prompt windows smaller, makes tool outputs easier to inspect, and reduces the chance that an agent will fabricate confidence from noisy retrieval.

I have seen this pattern play out repeatedly in record-linking work. Give an agent twenty possible matches for a company, city, or person, and it starts relying on superficial cues. Give it three well-chosen candidates with enough evidence to compare, and suddenly the reasoning improves. The tool’s design reflects that reality.

There is also a practical cost angle. Smaller outputs are easier to pass through coding environments, easier to log, and easier to audit when a user asks, “Why did the system pick this QID?” Bounded search is not just an efficiency trick. It is a reliability measure.

The five documented MCP tools

The project documents five MCP tools: kg_search, kg_entity, kg_related, kg_resolve, and kg_status. Taken together, they cover the common path from rough lookup to evidence-backed linkage.

A quick note before diving in: the real value here is not that there are five tools. Plenty of MCP servers expose a handful of commands. The value is that each tool has a distinct role, and the roles line up with the actual sequence people follow when disambiguating entities.

kg_search: the front door for candidate discovery

kg_search is the obvious starting point. Its job is to search for candidates in Wikidata, returning a bounded number of possible matches rather than a sprawling result set.

That sounds simple, but simple search is where many systems quietly fail. Entity names are messy. A local catalog might say “Mercury,” but that could point to a planet, a Roman deity, an element, an automobile brand, a song title, or something else entirely. The right search tool is not the one that retrieves every possible interpretation. It is the one that gives a small, workable set of plausible candidates the agent can inspect.

Because this MCP is explicit about bounded output, kg_search appears built for exactly that kind of disciplined candidate generation. In practice, that makes it suitable for two very different scenarios. The first is interactive research inside an MCP client, when a user wants a model to identify likely QIDs before going deeper. The second is programmatic pre-resolution, where an application needs a short candidate set to compare against local metadata.

What it does not appear to be designed for is exhaustive exploratory querying. If the task is “show me every entity that could possibly match this broad phrase,” this tool’s defaults are intentionally conservative. That is usually a good thing for agent workflows, but it is still a trade-off.

kg_entity: selected facts instead of indiscriminate dumps

Once a likely QID is on the table, kg_entity becomes the workhorse. The project documents selected-fact retrieval, including ranks, qualifiers, and references on request.

That detail matters more than it might seem at first glance. In everyday Wikidata use, a bare value is rarely enough. A date without a rank can hide whether it is preferred or deprecated. A role or affiliation without qualifiers can flatten important time boundaries. A statement without references may still be useful, but it carries a different evidentiary weight than a referenced one.

A good example is a person with multiple positions over time. If an agent only sees a single property value, it may summarize the subject inaccurately. Qualifiers often hold the dates or contextual limits that make the statement usable. Ranks matter when there are competing values. References matter when you want to explain why the tool surfaced a fact and how much trust to place in it.

This is one reason I prefer fact selection over raw entity dumps in operational workflows. Most downstream tasks do not need the whole item. They need the right ten percent of the item. A server that can return selected facts with ranks, qualifiers, and references on request is better aligned with how professionals actually work: retrieve less, understand more.

kg_related: helpful, but easiest to misuse

kg_related is the tool I would handle with the most care, not because it is weak, but because “relatedness” is one of the slipperiest concepts in knowledge systems.

When used well, a related-entity view can help an agent broaden context around a confirmed entity. It can surface adjacent entities that matter for interpretation, triage, or follow-up prompts. In a coding environment, it can also help a model propose sensible next lookups without reverting to generic language.

The problem is that relatedness is not identity. Teams sometimes let a related-entity result contaminate a resolution workflow. An agent sees a closely associated topic, drifts into it, and ends up answering the wrong question with impressive fluency. That is not a defect of the tool. It is a usage problem.

My rule of thumb is straightforward: use kg_related after you have high confidence in the base entity, not before. Once the QID is stable, relatedness becomes a context amplifier. Before then, it can become a distraction.

kg_resolve: where the project earns its keep

If I had to point to the part of this server that most clearly reflects hard-won experience, it would be kg_resolve.

The project documents deterministic resolution logic with explicit outcomes rather than fuzzy, informal judgments. That alone sets a strong tone. Resolution systems are often presented as smarter than they really are. Here, the server appears to prefer a narrower, inspectable decision model.

The documented outcomes are:

AUTO_MATCH
HOLD
AMBIGUOUS
NO_CANDIDATE

This is a small vocabulary, but it is exactly the right kind of vocabulary for production decisions.

AUTO_MATCH is for the rare cases where the evidence is strong enough that automation is justified. HOLD is the practical middle state that many systems skip, even though it is often the most honest answer. AMBIGUOUS tells you plausible candidates exist but are not safely distinguishable from the available evidence. NO_CANDIDATE is equally important because it prevents the common fallback of forcing a bad match just to satisfy a pipeline.

I like this outcome design because it respects operational reality. Most real datasets contain records that should not be auto-linked. Some are too sparse. Some are internally inconsistent. Some simply point to entities not represented well enough to identify through the available cues. A resolver that cannot say “stop” is not a resolver you should trust.

The project also states that it can link local records to Wikidata QIDs with inspectable evidence and explicit uncertainty when evidence is insufficient. That phrase deserves emphasis. Inspectable evidence is what lets a human reviewer step in without reverse-engineering the model’s thought process. Explicit uncertainty is what keeps a questionable match from becoming institutional truth.

For anyone evaluating MCP for google knowledge graph and wikidata in a real workflow, kg_resolve is likely the decision point that matters most.

kg_status: the quiet tool that saves debugging time

kg_status may sound like the least interesting tool, but status endpoints often become the most appreciated once a system is in use.

In local development, MCP tool failures are frequently caused by configuration drift, optional dependency assumptions, or external service availability. A status check gives both the user and the calling agent a fast way to understand what is currently reachable and properly configured.

That matters especially here because the project has an optional Google component. If Wikidata access is working but Google Knowledge Graph Search API access is not configured, a status tool can make that distinction visible without forcing the user to infer it from a cascade of partial failures. In an MCP client, that can mean the difference between a model that gracefully adapts its plan and a model that keeps retrying the wrong call.

Good status tools are rarely glamorous, but they reduce wasted time. In my experience, a few seconds of upfront visibility can save half an hour of confused troubleshooting in a coding session.

Where the optional Google cross-check fits

The project documents an optional Google cross-check using exact ID joins. Specifically, it references /m/ for Wikidata property P646 and /g/ for P2671. Just as important, it states that agreement between Google and Wikidata should be treated as provider concordance rather than proof of identity.

That is a mature stance. Cross-provider agreement can raise confidence, but it should not be mistaken for ground truth. Two systems can align because one imported from the other, because both inherited the same historical error, or because a coarse identity collapsed distinct things into one record long ago. Concordance is evidence. It is not absolute proof.

Still, there are clear moments when a Google cross-check adds value:

when a local record already carries a Google-style identifier
when a Wikidata candidate exposes P646 or P2671 and you want a strict join path
when you need an independent provider signal before moving from HOLD to human review
when you are auditing prior matches and want to flag places where providers disagree

The discipline here is to keep the exact-join logic exact. This project does not present Google as a free-form secondary search oracle for identity proof. It presents Google as an optional cross-check channel through known identifier mappings. That restraint is wise.

The CLI angle matters more than most MCP writeups admit

The project is described as both an MCP server and a CLI, with the CLI providing batch and evidence-export commands. For many teams, that dual interface is what turns a promising tool into a workable one.

Interactive MCP use is excellent for exploratory tasks. A developer in Claude Code or Cursor can ask for a search, inspect candidates, and retrieve selected facts as needed. But the minute you need to resolve hundreds or thousands of local records, an MCP interaction alone is not enough. You need repeatable runs, batch processing, and evidence exports that can be reviewed or archived.

Batch support is especially relevant for data stewardship work. If a resolver marks a set of records as AMBIGUOUS or HOLD, that output needs to travel somewhere useful, often into a spreadsheet, queue, or review system. Evidence export is how you preserve the context that justifies the decision. Without it, a human reviewer receives a cryptic status with no efficient way to verify the call.

This is where a lot of seemingly polished tools break down. They demo well in a chat pane, then fall apart when confronted with nightly jobs, QA checks, or audit requirements. The documented CLI features suggest that this project has at least considered the realities of operational use.

How this compares to broader Wikidata MCP usage

The broader Wikidata MCP story is about giving language models standardized ways to query and explore Wikidata through official APIs and query services. That is useful for open-ended research, ontology inspection, and general fact retrieval.

This project appears to live one level closer to applied record linkage. It narrows the interface around tasks that are common and failure-prone in everyday agent use: searching for likely entities, reading the right facts, resolving a local record to a QID, and documenting why the result is or is not safe to accept.

That does not make it better than the broader MCP for Wikidata ecosystem in every scenario. If your work involves exploratory SPARQL-style analysis or graph-wide questions, you will likely want more than this server offers. But if your problem is “help an agent identify the right entity and justify the match,” the narrower focus is often an advantage.

I would frame the trade-off like this. A broad Wikidata interface gives you range. This project appears to give you guardrails. In production environments, guardrails are frequently the harder thing to build.

Practical judgment on who should use it

The best fit for this MCP is not every knowledge-graph user. It is teams and individuals who care about verifiable entity resolution inside agent workflows.

If you are enriching local records with Wikidata QIDs, the deterministic outcomes and inspectable evidence are directly relevant. If you are building assistants inside coding environments that need to look up entities without hallucinating confidence, the bounded candidate design will likely feel refreshing. If you need optional Google concordance without turning that concordance into false certainty, the documented exact-ID join model is sensible.

If, however, your main need is broad semantic exploration, this may feel intentionally constrained. The project is read-only and focused. It does not promise graph editing, unlimited search expansion, or authority beyond the providers it consults. Those are limitations, but they are honest limitations.

That honesty is what stands out most. The project does not pretend that provider agreement proves identity. It does not pretend that all records can be auto-matched. It does not bury uncertainty behind a confidence score and hope nobody asks follow-up questions. For work involving MCP for google knowledge graph and wikidata, that restraint is a feature, not a missing capability.

What makes this project worth watching

Plenty of knowledge tools can retrieve facts. Fewer can help an agent behave responsibly when identity is uncertain. The documented shape of this server suggests that it was designed with that problem in mind from the start.

The combination is what gives it practical weight: bounded search, selected-fact retrieval with ranks and qualifiers, deterministic resolution states, optional exact-ID Google cross-checking, and CLI support for Learn more batch processing and evidence export. None of those features alone is revolutionary. Together, they form a coherent stance on how agent-facing entity resolution should work.

That stance is especially useful for anyone evaluating MCP for wikidata or MCP for google knowledge graph in settings where mistakes are expensive. The most dangerous system is not the one that says “I cannot tell.” It is the one that sounds certain when it should not.

On that point, this tool appears to have chosen the right side.