359 Data Sources, One Schema: How NeuralVerge Normalizes Company Data
MCP server data sources only work if every tool answers in one shape. How 359 source pages share one envelope an agent can read, and where it stops.
By the NeuralVerge team · 12 min read · Updated October 2026
▸On this page
MCP server data sources only help an agent if every tool answers in the same shape. An agent that can call ten different data tools has a problem before it reaches the data: one returns company_status, another returns status, a third buries the same fact in a paragraph of text. The fix is normalization, a predictable envelope around source-specific fields. NeuralVerge applies it across 359 source pages, which are individual lookups, not 359 publishers.
The short version
- —The claim: an MCP server that exposes many data tools is only as useful as its consistency. Normalization is most of the value; the protocol only handles discovery and transport.
- —What is uniform: the envelope (session id, kind of lookup, echoed request, readable summary, structured result), the way to make a request and the way to read a result. What is not uniform: the fields inside, because a registry and a funding profile hold different facts.
- —What the number means: 359 is the count of source pages in the source catalog, each one a single lookup. It is not a count of publishers, which is a smaller number.
- —Who it is for: teams giving an agent lookups it can chain.
- —What it costs: each lookup is priced in points on its own source page. The Finnish register lookup used below is 5 points, which is $5 per 1,000, charged only when the company resolves.
What "one schema" actually means
The phrase is useful shorthand and slightly dangerous. The catalog spans several families: company intelligence, marketplaces, product reviews, corporate registries, contact enrichment and professional networks. No single schema can describe a Finnish company register entry, a product listing and a contact record with the same fields, and a system that claims otherwise is either hiding information or inventing it.
What can be uniform is the contract around the data. Every data source answers with the same envelope:
- —a session id you can trace,
- —the kind of lookup that ran,
- —an echo of the request parameters, which for a URL-based lookup includes the URL it read,
- —a readable
humansummary, - —and a structured
machineresult.
So "one schema" here means one envelope, one way to make a request, one way to read a result and one way to find out where a value came from. It does not mean one flat table that every source is forced into.
Source pages, not publishers
The figure of 359 comes from counting the source pages on this site. A source page is one lookup: a company record from one registry, a search on one marketplace, a profile from one directory. A registry that offers a company lookup, a search and a filings lookup is several pages. So the number measures how many distinct things you can ask for, not how many organizations publish the data.
Why an MCP server for data sources needs this layer
A model reads each tool's name and description to decide what to call, then reads the result to decide what next. When a server advertises many tools that all return company data, both steps get harder if the tools are inconsistent:
- —Tool selection gets noisier. Many tools with overlapping descriptions and different argument styles give the model more ways to pick the wrong one. Consistent naming and inputs narrow the choice.
- —Result reading gets more expensive. A model can read a raw, source-specific payload, but every quirk it has to interpret costs tokens and adds a chance of misreading. Typed fields with stable names cost less to read and are harder to get wrong.
Without normalization, the integration work moves from your codebase into the model's context window, where it is slower and less reliable.
The problems normalization has to solve
Normalizing company data is six separate problems, each with its own failure mode. Treating them as one is how systems end up confident and wrong.
1. Entity resolution: which company is this?
Before normalizing what a source says, you have to know you are asking about the right company. Legal names differ from trading names, and one brand can operate through entities in several countries.
Registries have dedicated lookups that take a company identifier, and profile sources take a profile URL. An identifier removes ambiguity; a name does not. When all you have is a name, resolving it to an identifier is a separate step, and it is the step where research is the right tool, not a lookup. The AI research capability exists for the question "which entity is this," and only then do direct lookups make sense.
The rule for an agent: resolve once, keep the identifier, pass identifiers to every later call.
2. Field mapping: same fact, different names
Sources describe the same fact in different ways. A registry says a company is "Active," a professional profile says nothing about status at all, and a funding profile publishes an employee count as a band rather than a number.
Field mapping means deciding, source by source, what each field means and giving it a stable name and type. Two rules keep this honest. Map only what genuinely means the same thing: a registered office address and a location listed on a profile are related but not identical. And preserve what the source said: a funding total published as text stays text, and a size band stays a band. Converting everything to the most convenient type quietly discards information.
3. Provenance: where did this value come from?
A value without a source is a claim you cannot check. Provenance is the answer to "says who, and when."
In this catalog, provenance travels at the level of the lookup. Every response echoes the request it ran, and for a URL-based lookup the URL it was read from, and carries a session id that can be traced back to the request. Because each source is its own lookup and returns its own envelope, the fields inside a result all share one origin, and the origin is stamped on the result.
The limit: provenance is per result, not per field. If you merge three lookups into one record, keep each field next to its source URL. For research questions, citations do the same job at the claim level.
4. Conflicting values: what to do when sources disagree
Two authoritative sources will sometimes disagree, and no schema fixes that. A registry holds the address a company filed; a profile holds the one it chose to show.
There are three defensible ways to handle it, and none is "pick one quietly":
- —Prefer by field. Decide in advance which source is authoritative for which fact. The legal register wins on legal status, legal form and registered address. A professional profile is more likely to be right about current headcount and how the company describes itself.
- —Prefer by recency. Where one source was updated more recently, the fresher one is usually the better bet, if you can tell which.
- —Surface the disagreement. When neither rule settles it, report both values with their sources and say they differ.
A single-source lookup reports one source and nothing else. Cross-checking happens in research, where facts are compared across sources and disagreements are carried into the answer. If you reconcile lookups yourself, keep both values until you have a reason to drop one.
5. Freshness: how old is this answer?
Freshness is easy to overstate. Source lookups in the catalog are read at request time, so the answer reflects the source as it stands when you ask, rather than a copy stored weeks ago. That separates this catalog from stored B2B contact and company databases.
Real-time fetching is not the same as real-time facts. A registry record changes when the company files something; a profile changes when its maintainers update it. A live read of a stale record returns a stale value, quickly.
6. Missing values: absent is not zero
A source does not hold every field for every entity, and the layer has to say so.
In this catalog, a field the source does not hold comes back empty rather than guessed, and a lookup that resolves nothing returns nothing rather than a near match. Both behaviors matter to an agent. An empty field means "unknown," not "none," "false" or "zero." An agent that reads a missing employee band as zero employees will write a wrong sentence with great confidence.
A worked example: Acme Oy (Finland)
To see the six problems in one place, take an illustrative task: an agent is asked to prepare a short profile of Acme Oy (Finland) before a supplier review.
Resolve the entity. The agent starts with a name. Names are ambiguous, so it asks a research question first, which legal entity in Finland trades as Acme, and gets back a business ID with citations. From here it carries the ID, not the name.
Read the register. The agent runs the Finnish company register lookup for that business ID. The result holds company name, company form, home municipality, main line of business and registered postal address, plus the register URL and a session id. These are legal facts, and the agent labels them that way.
Read the network profile. The agent then calls the professional-network company search source, which returns a name, an industry, a headquarters location, a follower count and a description. This is how the company presents itself, and the agent labels it that way.
Compare. The two results do not agree on everything. The register lists a registered postal address in one city, while the profile lists headquarters in a neighboring one. The register carries a legal form; the profile does not. The agent does not merge the two into one "address" field: it reports the register address as the legal address, the profile location as a presented one, and notes that they differ.
Handle the gaps and report. Some fields come back empty, so the agent writes "not stated in the sources checked" instead of filling them in. The final output lists each fact next to the URL it came from and notes that each value was read at request time.
None of that required the agent to know either source's internal layout. A question this broad is also a natural fit for research, which runs the cross-checks and returns cited claims in one call. The Finnish company register source page shows the input the register step takes, the fields it returns and its known gaps.
REST and MCP
NeuralVerge runs a hosted remote MCP server at https://mcp.neuralverge.ai/mcp, so there is no server for you to build or host. You add the URL to an MCP client and sign in through the browser. Search, AI Extract (run_extract) and the data sources are tools on it; your client's tool list after sign-in is the authoritative one. AI research runs over REST only. Setup for Claude and other clients is in the MCP server setup guide.
Each source becomes a tool with a name, a description of what it takes and returns, and a set of arguments. Tool names use underscores; the REST paths use hyphens. The Finnish register step from the example is the tool run_fi_companies, called with the Business ID:
{ "tool": "run_fi_companies", "arguments": {"company": "0112038-9"} }
The same lookup over REST is a POST to https://api.neuralverge.ai/functions/v1/run-fi-companies with the same body and an API key in the Authorization header. The tool wraps that endpoint with the same inputs and outputs, so result-reading code does not change with the transport. Use MCP when a model has to choose the lookup itself mid-task, and REST when your own code already knows which call to make.
Three design choices matter for data tools:
- —One tool per lookup, named for what it returns. A record lookup takes an identifier; a search takes a query and returns a list.
- —The same result envelope from every tool. The agent learns the shape once.
- —Descriptions that state limits. Which country a register covers, whether a name or an identifier is expected, and which fields can be empty belong in the description, because that is what the model reads.
Cost and limits
Lookups are priced in points, shown on each source page. The Finnish register lookup is 5 points, charged only when the company resolves, so a miss costs nothing there; check each source page for how it bills.
A normalization layer is honest when it says what it does not do:
- —It does not make sources agree. It makes disagreements visible and attributable. Which value wins is a policy your application owns.
- —It does not create data a source does not hold. Missing stays missing.
- —It does not equalize coverage. A registry covers its own country and nothing else.
- —It does not guarantee accuracy. A normalized wrong value is still wrong. The origin URL is there so a person can check.
How to decide
Run one real entity through two sources and compare the results with what you expected. It answers most of these faster than any feature list.
- —What is uniform, exactly? Compare three responses from three sources side by side.
- —What does the big number count? Source pages, publishers, records? A count of lookups is fine as long as it is called that.
- —Does every value carry an origin? Look for a source URL and request id on each result.
- —What happens on a miss? Try an identifier that does not exist; it should come back empty, not as a near match.
- —Can you keep both values in a conflict? Without attribution you cannot reconcile later.
- —Is freshness stated honestly?
- —Are coverage limits stated per source? They should be visible per source.
The use cases that benefit most are supplier and counterparty checks, account research that ties every fact to its origin, and agents that chain lookups and decide mid-task what they still need.
Frequently asked questions
Does one schema mean every source returns the same fields?
No. Every source returns the same outer envelope: a session id, the kind of lookup, an echo of the request parameters, a readable summary and a structured result. The fields inside the structured result are specific to each source, because a corporate registry and a funding profile simply hold different facts. What stays consistent is the shape around them and the way each field is typed and named within its source.
What does 359 mean: sources or publishers?
It is the number of source pages in the catalog, counted from the pages on this site. Each page is one individual lookup, such as one registry's company record or one marketplace's product listing. It is not a count of distinct publishers, and the number of underlying publishers is smaller because several lookups can read the same one.
What happens when two sources disagree about the same company?
A single-source lookup returns what that source says and does not compare it with anything else. When you ask a question through AI research, the pipeline checks facts across more than one source where more than one is available and surfaces disagreements instead of silently picking one. If you build your own reconciliation on top of individual lookups, keep both values and their source URLs and decide by field which source you trust.
How fresh is the data an MCP tool returns?
Source lookups are read at request time, so the answer reflects the source as it stands when you ask. Fetching in real time does not make the underlying record new: a registry record is only as current as the registry's own last update, and a profile is only as current as whoever maintains it.
What does a normalized result look like when a field is missing?
Fields a source does not hold for a given entity come back empty rather than guessed. An empty value means the source did not have it, not that the value is zero or false, and an agent should treat it as unknown.
Is every one of the 359 source pages available as an MCP tool today?
Search, AI Extract and the data sources are tools on the hosted MCP server, and corporate registries are dedicated source tools. AI research runs over REST only. Each tool is a thin wrapper of its REST endpoint, with the same inputs and the same response shape. The tool list your client shows after sign-in is the authoritative answer for your account.
Related articles
A data catalog API gives you one request format across 359 sources: registries, startups, marketplaces, social and enrichment. See a real request and response.
One API for AI agents: research, extraction and enrichment on one account and one response shape, reached over REST or as MCP tools on a single URL.
A cost model for stitched data pipelines, and what a research extraction enrichment API on one account, reached over REST or MCP, changes in the math.
About NeuralVerge
Give your agents structured, cited, real-world data from 300+ sources and the open web — through one API or MCP server.
AI Agents & MCP on the NeuralVerge blog.