I love board games. They are a very good excuse to entice my kids away from their books and spend some time with the parents. Plus I think I read somewhere that they increase neuroplasticity and I could use plenty more of that.
I decided to use Sanity Context to build an agent that recommends games based on my interests. Sanity Context is an MCP server. MCP (Model Context Protocol) is an open standard for connecting AI agents to external data and tools. Any agent that supports MCP can connect to it: Claude, GPT-4o, whatever you're building with for your next project. In this tutorial I'll walk through the key steps so you can follow along or use your favorite coding assistant to build something similar.
If you'd like to follow along with the full code files checkout this repo:
Before we dive in any further let's see this thing in action:
I asked the agent, using GPT-4o, to recommend a new cooperative board game for my family that uses narrative story telling and city-building. When I tried this same query with OpenAI's latest GPT 5.5 model it was not able to find me a board game made later than 2023. Instead my agent recommended a top-rated game from this year called Cozy Stickerville.
Notice that my agent didn't guess. Behind the scenes it ran a GROQ query (GROQ is Sanity's open-source query language) against our Content Lake and returned a game that was released in 2026, has both mechanics tagged in their records, directly from BoardGameGeek's (BGG) API. Rad, let's build it.
By the end of this tutorial you'll have:
boardGame schema, populated from BGG's XML APIFor this demo specifically I wanted to focus on the build patterns of building an agent with Context and show that agents can live in different interfaces - which means there is no frontend. It's a CLI, ya' dig?
node --version to confirm.npm create sanity@latest as shown belowAuthorization: Bearer … on every API request. See Using the XML API.Follow the prompts. When asked to install the MCP server, choose yes, it allows you and your agent to interact with Sanity's docs and tools directly.
Expected output:
Your project ID will now be in will now be in sanity.config.ts. Keep it handy, we'll need to add this to the .env file.
Or clone from GitHub: Clone the repo, run npm install, then run:
This will walk you through logging in and selecting (or creating) a project, and automatically write your projectId and dataset to a .env file. Then copy any remaining variables from .env.example and update sanity.config.ts and sanity.cli.ts to match.
In Sanity, a schema is a TypeScript definition that describes the shape of your documents, what fields they have, what types those fields are, and how they're validated. It's the contract between your content and everything that reads it: Studio uses it to render the right editing form, your frontend uses it to know what to expect, and Context uses it to expose your data structure to the AI agent.
The default Studio template includes a placeholder schemaTypes/index.ts with a sample type. We're going to replace that with the actual boardGame document type and split it into its own file while we're at it, which is the convention for maintainable Sanity projects.
Create a new file at schemaTypes/documents/board-game.ts:
Then update schemaTypes/index.ts to import from it:
The mechanics and categories arrays are what make the GROQ queries genuinely useful later - they let the agent filter by structured tags rather than approximate text matching.
Next we need to deploy the schema to Content Lake so the Sanity Context server knows your data shape, we'll use the following sanity deploy command which has the added benefit of deploying our studio as well.
Install the XML parsing package:
Create ingest.mjs at the project root. This is not the full file, but gives you the shape. You can see my version here: https://github.com/jarodreyes/boardgame-sanity-cli/blob/main/ingest.mjs
Create a .env file at the project root. For Sanity, go to sanity.io/manage, open your project, click API → Tokens, and create one with Editor permissions. For BGG, use the bearer token from Applications → Tokens for your registered app.
Run the ingestion:
`getCliClient()` picks up your projectId, dataset, and apiVersion directly from sanity.config.ts — no duplication. The `--with-user-tokenflag` passes your active sanity login session to the script, so you don't need a separate SANITY_API_TOKEN environment variable for local ingestion runs. You only need an API token when running in a non-interactive environment like CI.
Expected output:
BGG's thing endpoint accepts at most 20 IDs per request; the script batches automatically and waits 2 seconds between batches.
Start the Studio (npm run dev, then open localhost:3333). After the default small ingest you should see on the order of ~60 board games; each with ratings, complexity weights, mechanics, categories, player counts, playtime ranges, and designer credits from BGG.
Sanity Context is an MCP server. Once configured in your Studio, it gives any MCP-compatible agent three tools to work with: initial_context (a compressed overview of your schema and document count), groq_query (live GROQ access to your Content Lake), and schema_explorer (field-level inspection so the agent builds accurate queries without guessing at field names).
Sanity ships a skill that automates the Context configuration. Run it from your coding assistant and it handles the plugin install, Context document creation, and MCP URL setup.
To set it up manually:
Open sanity.config.ts and add the plugin:
Restart the Studio after the config change.
In the Studio sidebar, you'll see a new Context section. Click it, then Create new Sanity Context. Fill in these fields:
Save the document. The Studio generates an MCP URL (the API path includes a date version, e.g. v2026-04-09 — use exactly what Studio shows, not a guess):
Copy it.
Create agent.mjs at the project root:
The system prompt is worth understanding because it controls how the agent queries your data. It sets the query strategy (what to try first, how to widen if a query returns zero results), the BGG-specific field conventions (exact tag strings like "Co-operative Play" rather than the casual phrase "co-op"), and the temporal logic (how the agent interprets "new" or "recent" relative to the current date).
The prompt in this repo was written with help from the Sanity Context skill and iterated against real queries. It's detailed because GROQ is precise. A vague "find cooperative games" won't match anything if the agent guesses at a field name. The tradeoff is token cost per call: a longer system prompt means slightly higher cost per query, but it cuts down on the number of follow-up tool calls the model needs to make.
You'll want to customize this for your own data. The field names, array values, and fallback logic are all specific to the BGG dataset. Swap those out for your schema and you have a solid starting point.
The agent script depends on two more packages: the Vercel AI SDK (ai) and an OpenAI provider (@ai-sdk/openai). Install them with npm:
Worth pausing here on what an agent loop actually is. When you call generateText, the model runs in a loop rather than responding once and stopping. The model decides to call a tool, the SDK executes that tool against your MCP server, the result comes back to the model, and the model decides what to do next. That cycle continues until the model has enough information to give a final answer, or until it hits the stopWhen limit.
In this agent, that means the model is running live GROQ queries against your Content Lake mid-conversation, reading real results, and deciding whether it needs more data before responding. The retrieval happens inside the loop, driven by the model.
The OpenAI provider is the adapter that connects generateText to GPT-4o. The Vercel AI SDK supports other providers too, so if you'd rather use Anthropic or Gemini, swap the provider import and you're good.
Add three more variables to .env. Create a Sanity API token with Viewer permissions:
Now you can start building your own agents on top of your content. Here are a few queries that show just how precise this gets:
The agent runs a GROQ expression against real records, reads the result, and gives you an exact answer. It counts array lengths, finds maximums, traverses references, whatever your schema supports.
Swap out board games for a product catalog, a documentation site, a recipe database, or a content library. The architecture is the same. The agents you build for your users get smarter the more you invest in your content, not because a new model dropped, but because your data got better.
When you ask the agent a question, it reaches the Sanity Context MCP server. The agent doesn't retrieve context and answer from memory. It runs queries, reads the results, and builds its response from live data. The instructions in the Context document guide how it frames and presents those results.
On top of all this, you can wire up any agent, using any AI you want, and have complete control of the experience for you or your end user/customer… all using Javascript/Typescript/language of your choice.
Your Sanity content becomes structured data the agent can query with the precision of a database.
I am proud to say that after the agent recommended Cozy Stickerville, I actually went and bought it, excited to play it with the fam tonight.
If you are building with Sanity Context or want help figuring out how to use it for your work join our Discord. We will be having some live sessions showing off agents built with Sanity and it'll be a great place to ask questions.
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。