We are building a Model Context Protocol server for SpotCrime. It is in early access now, with general availability targeted for September 2026. The early-access build exposes a structured crime-incident feed by location as a native tool; a numeric neighborhood safety score is on the roadmap. This post explains what we're building, how the SpotCrime Harness works, and why the agentic pattern changes what crime data infrastructure needs to look like.
The problem with crime data and agents today
If you are building an AI agent today and you want to include crime intelligence in its reasoning, your options are limited. You can hit a REST endpoint and parse the response inside your orchestration layer. You can embed a static crime dataset and retrieve from it with a vector search. You can prompt the model to reason about neighborhood safety from training data — which means the model will hallucinate plausibly, confidently, and incorrectly.
None of these are good. REST requires glue code at every integration point. Embedded datasets go stale and lack geographic coverage. Training data has no verifiable freshness, no geographic precision, and no attribution chain.
The root issue is that crime data has been designed for humans and REST clients. It has not been designed for the inference step of a language model operating inside an agent loop. That is the gap the SpotCrime MCP server is built to close.
What MCP is and why it matters for data providers
Model Context Protocol (MCP) is an open standard, originally developed by Anthropic and now supported across the agent ecosystem, for exposing structured tools directly inside a model's context window. An MCP tool is not an API wrapper. It is a first-class capability that an agent can call mid-reasoning — inline, inside the agent loop, without leaving the inference step.
The difference matters. When an agent has access to a REST API, it has to plan a call, format a request, parse a response, handle errors, and translate the result into something it can reason about. Every one of those steps is a failure surface: wrong parameters, brittle parsing logic, unhandled error states, or a model that misreads a JSON blob and proceeds on a false premise.
When an agent has access to an MCP tool, none of that applies. The tool has a defined schema. The model calls it with typed inputs. It receives typed output. The inference continues. The data layer is transparent to the reasoning layer.
For a data provider like SpotCrime — where the value is structured, verifiable, frequently-updated location intelligence — MCP is the right primitive. We are not a search engine. We are not a document retrieval system. We are a structured data source with 500 million indexed incidents across 22,000 cities. MCP is how that data belongs inside an agent.
The two tools
The SpotCrime MCP server covers two tools. That is intentional. We are not building a tool for every possible query pattern. We are building the two that cover the majority of agent use cases with the minimum surface area. One — the incident feed — is available in early access today. The other — the safety score — is on the roadmap.
get_crime_incidentsEarly access
Returns a structured array of recent crime incidents near a location — a latitude/longitude and radius — from a rolling 90-day window. Every element includes incident type, date, coordinates, and description. It wraps SpotCrime's live incident API as a native tool call: the citation layer, for agents that need to show their work. Grounded in 500M+ historical incidents across 22,000+ cities.
The output is designed to be inference-ready. Each incident is a discrete, attributable event the model can cite directly — not a paragraph summary, not an interpolation, not a model generation. No summarization step, no hallucination risk on the data. The agent receives a structured array and continues reasoning.
This tool is stateless. An agent can call it at any point in a reasoning chain — across a loop of 500 policy addresses, in a multi-step pre-trip brief, as a grounding node in a real estate recommendation pipeline — without side effects. An executive protection agent can cite specific incidents with specific dates and locations; a real estate agent surfacing a neighborhood risk flag can point to the underlying events.
get_safety_scoreOn the roadmap
A planned tool that will return a single 0–100 neighborhood safety score for a location — percentile-ranked nationally and grounded in the same 500M+ incidents. Where the incident feed gives an agent facts to cite, the safety score will give it one number to compare, filter, and threshold in a single reasoning step. It is on the roadmap and not part of the early-access build; the shape below is illustrative, not yet callable.
The SpotCrime Harness
The harness is the developer integration layer that wires the MCP server into your agent runtime. It handles authentication, schema validation, response formatting, and rate-limit management — so your model receives clean, inference-ready output from the first call, not raw HTTP that needs interpretation.
The design principle is minimum configuration. One block in your agent runtime's config file is all that connects your agent loop to real-time crime incidents across 22,000+ cities and 500M+ records. There is no orchestration middleware to install. No custom tool wrapper to write. No translation layer between the data format and the model's context.
{
"mcpServers": {
"spotcrime": {
"command": "npx",
"args": ["@spotcrime/mcp-server"],
"env": {
"SPOTCRIME_API_KEY": "your-key-here"
}
}
}
}The same config pattern applies to Cursor (.cursor/mcp.json) and Windsurf (.windsurf/mcp.json). For LangChain, LlamaIndex, and AutoGen, the harness exposes a standard MCP tool interface that maps directly to each framework's tool primitive. The harness ships with local test tooling — you can validate get_safety_score output before connecting to a production agent.
What agents build with this
The two-tool surface is intentionally narrow. What it unlocks is broad.
Real estate AI.
An agent building a market analysis calls get_crime_incidents across candidate areas in a target geography, ranks by recent reported activity, and returns a filtered shortlist to the user. No manual lookup. No static dataset. No scraping. The agent does in seconds what a human analyst would spend hours on.
Executive protection.
A pre-trip brief agent retrieves recent incidents along a principal's itinerary and route corridors, then generates a structured risk brief with specific incident citations. The brief is grounded, attributable, and auditable — not a model generation from training data that may be months out of date.
Autonomous insurance underwriting.
An underwriting agent pulls incident history for 500 policy addresses in a single batch loop — get_crime_incidents called in parallel, results fed directly into a risk tier model. The stateless design makes the tool safe to parallelize at any scale. (When the planned safety score ships, it will collapse each result to a single comparable number.)
Multi-agent pipelines.
In a multi-agent architecture, SpotCrime tools are chain-safe grounding nodes. An orchestrator agent dispatches a sub-agent to pull incidents for a set of locations; the sub-agent calls get_crime_incidents and returns structured results; the orchestrator incorporates them into a downstream decision. No state to pass. No format to negotiate. The output schema is fixed and documented.
Coverage and data quality
The SpotCrime MCP server covers 22,000+ cities across the United States, grounded in 500M+ historical incidents. Priority feeds update every 15 minutes. The full methodology — decile cutoffs, comparison populations, stated limitations — is published and machine-readable at spotcrime.io/methodology and spotcrime.io/methodology.json.
We document limitations explicitly because agents that cite our data need to cite it accurately. Coverage is not uniform across agencies. Some jurisdictions lag on reporting. Some rural geographies have thinner data density than urban ones. The methodology page states all of this. The MCP output does not hide uncertainty — it represents what the data supports.
Early access
The SpotCrime MCP server is in early access, with general availability targeted for September 2026. Early access is open now to teams building agentic applications where location risk is part of the reasoning chain.
If you are building a real estate AI, an executive protection platform, an autonomous underwriting agent, a multi-agent travel safety system, or any LLM-powered application that needs grounded, structured crime intelligence — we want to work with you. Request access, tell us what you're building, and we will prioritize your integration.
Request Early Access
We prioritize agent-native integrations. Tell us what you're building.
What comes next
The early-access harness ships with get_crime_incidents; get_safety_score follows on the roadmap. Behind the harness sits the full planned SpotCrime v1 endpoint set — trends, batch scoring, real-time alert subscriptions, and the executive risk package. As those endpoints reach production, the MCP tool manifest expands.
The machine surfaces — /openapi.json, /llms-full.txt, /.well-known/ai-plugin.json, /methodology.json — stay current and CORS-enabled so any agent runtime can discover and evaluate the API surface without a human in the loop.
SpotCrime.io exists to be the crime data surface that agents find, evaluate, trust, and integrate autonomously. The MCP server is the most direct expression of that goal.