A working LM Studio mcp.json you can paste today, explained entry by entry, plus a side by side look at the best MCP servers for web search: Brave Search, Tavily, Exa, DuckDuckGo and Fetch. You get exact package names, tool names, token settings and the safety checks to run first.
Your local model is fast, private and sharp, and it still believes it is living in the month its training data stopped. Ask LM Studio's chat window about last week's release and you get a confident guess. The fix is one JSON file. Add an MCP server for web search to mcp.json, and the same model starts calling a search tool, reading real pages, and answering with sources instead of memory.
This article gives you a working LM Studio MCP mcp.json example you can paste today, then compares the five web search servers people reach for most: Brave Search, Tavily, Exa, DuckDuckGo and the official Fetch server. Every config below comes from each project's own documentation, so the package names, environment variables and tool names are the real ones.
A language model is a snapshot. Whatever it knew on the day training ended is all it will ever know, no matter how long you leave it running on your desk. That is fine for rewriting an email or explaining a regex. It is painful for anything that moves: library versions, prices, release notes, the error message from last month's update.
Pasting web pages into the chat by hand works, but it burns your context window and your patience. A search tool lets the model decide when it needs fresh facts, fetch them, and fold them into the answer.
The Model Context Protocol (MCP) is a standard way for an app to connect a model to outside tools. LM Studio acts as the host: it starts or connects to each server listed in your config, asks what tools they offer, and passes those tool descriptions to the model. When the model decides to call one, LM Studio runs it and feeds the result back into the chat.
💡 You write no code for this. A search server is a small program someone else maintains. Your only job is telling LM Studio how to launch it.
MCP support arrived in LM Studio 0.3.17, and the app follows Cursor's mcp.json notation. That matters because most server READMEs show a Cursor or Claude Desktop snippet, and those snippets paste in with little or no change.
Inside the app, open the Program tab in the right-hand sidebar, click Install, then choose Edit mcp.json. The built-in editor is the safest route because you see mistakes as you type.
If you would rather edit the file directly, these are the paths:
| System | Path to the file |
|---|---|
| macOS | ~/.lmstudio/mcp.json |
| Linux | ~/.lmstudio/mcp.json |
| Windows | %USERPROFILE%/.lmstudio/mcp.json |
After you save, check the Program tab: each server in the file should appear there with its tools. Some MCP authors also publish an Add to LM Studio button that writes the entry for you, which is handy when a server has a long config.
Every entry sits inside one top-level object called mcpServers. Each server gets a name you choose, followed by either a url (a remote server) or a command (a local process).
The official LM Studio docs use the Hugging Face MCP server as the remote example:
{
"mcpServers": {
"hf-mcp-server": {
"url": "https://huggingface.co/mcp",
"headers": {
"Authorization": "Bearer <YOUR_HF_TOKEN>"
}
}
}
}
Three details matter here. url points at the hosted server. headers carries your credential. And the placeholder in angle brackets has to be replaced with a real token before the server will connect.
Local servers use command, args and env. This is Brave's own snippet for the Brave Search MCP server:
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
"env": {
"BRAVE_API_KEY": "YOUR_BRAVE_TOKEN"
}
}
}
}
npx ships with Node.js, so install that first. The -y flag skips the confirmation prompt that would otherwise hang a background process, and --transport stdio tells the server to talk to LM Studio through standard input and output. The env block hands your token to the server as an environment variable, which is how nearly every search server expects to receive it.
A realistic file mixes sources: Brave for broad search, Fetch for reading a page in full, DuckDuckGo as a fallback that needs no account.
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
"env": {
"BRAVE_API_KEY": "YOUR_BRAVE_TOKEN"
}
},
"fetch": {
"command": "uvx",
"args": ["mcp-server-fetch"]
},
"ddg-search": {
"command": "uvx",
"args": ["duckduckgo-mcp-server"]
}
}
}
uvx comes from the uv Python tool, so the two Python servers need uv installed, just as the Node server needs Node.
💡 Two commas cause more broken configs than anything else: a missing comma between servers and a trailing comma after the last one. JSON allows neither, and it has no comments either.
Search servers do three different jobs: find links, return clean page text, and read one specific URL. The best setups pair a finder with a reader instead of asking one server to do everything.
Brave is the default pick for most people. The package is @brave/brave-search-mcp-server, the token goes in BRAVE_API_KEY, and the tool list is broad: brave_web_search, brave_local_search, brave_video_search, brave_image_search, brave_news_search, brave_summarizer, brave_place_search and brave_llm_context.
Brave returns raw ranked results (links and snippets) and lets your local model do the reading. That keeps responses small, which matters when your context window is limited. The repository notes that Pro plans add extras such as additional snippets and full local search.
Tavily leans toward extraction. Its tools are tavily-search, tavily-extract, tavily-map and tavily-crawl, so the model can search, pull the text of a page, map a site or crawl it. The local entry looks like this:
{
"mcpServers": {
"tavily-mcp": {
"command": "npx",
"args": ["-y", "tavily-mcp@latest"],
"env": {
"TAVILY_API_KEY": "your-tavily-token"
}
}
}
}
Tavily also runs a remote server at https://mcp.tavily.com/mcp/?tavilyApiKey=<your-token>. The local version above is the better habit, because it keeps your token out of a URL.
Exa is the shortest setup of the five, since it is hosted. There is nothing to install, so no Node and no Python:
{
"mcpServers": {
"exa": {
"url": "https://mcp.exa.ai/mcp"
}
}
}
The default tools are web_search_exa, which returns search results with clean content, and web_fetch_exa, which reads a page as markdown. Exa accepts a token as a URL parameter or in an Authorization header. The header is the tidier choice.
No account, no token. Run uvx duckduckgo-mcp-server and you have search, fetch_content and expand_link. It is the quickest way to prove your whole setup works before you sign up for anything.
The trade-off is rate limits. The defaults are 30 searches per minute and 20 page fetches per minute, adjustable with the DDG_SEARCH_RPM and DDG_FETCH_RPM environment variables. On an HTTP 429 response the server honors Retry-After and retries once.
Fetch comes from the official MCP servers repository and does one thing: it downloads a URL and converts the HTML to markdown. Its fetch tool takes a url, plus optional max_length (default 5000 characters), start_index and raw.
That start_index parameter is useful. When a page is longer than one response, the model can ask for the next slice instead of losing the end of the article. Fetch honors robots.txt for model-initiated requests by default, and its documentation warns that it can reach local and internal IP addresses, which is a real risk on a work machine.
| Server | Launch | Token | Tools | Best for |
|---|---|---|---|---|
| Brave Search | npx | Yes, BRAVE_API_KEY | brave_web_search plus seven more | General web search |
| Tavily | npx or remote | Yes, TAVILY_API_KEY | tavily-search, tavily-extract, tavily-map, tavily-crawl | Research that needs page text |
| Exa | Remote URL | URL parameter or header | web_search_exa, web_fetch_exa | Zero install setup |
| DuckDuckGo | uvx | None | search, fetch_content, expand_link | Free testing |
| Fetch | uvx | None | fetch | Reading a known URL |
Three starting points suit most people:
Not every model can call tools. A model has to be trained to emit a structured tool call, and LM Studio marks tool-capable models in its model list with a hammer badge. Pick one without it and the model will talk about searching but never actually search.
Two settings help just as much as the model choice:
Before you download a multi-gigabyte model, rehearse your prompts on a hosted one. GPT OSS 20B is an open-weight, 20-billion-parameter language model, and its model page offers unlimited generations with no credit caps.
One honest limit: this hosted model runs in the browser and does not connect to your local MCP servers. Use it to polish the system prompt and to see how a model summarizes pasted search results, then carry the winning prompt back to LM Studio.
| Setting | Default | Use it for |
|---|---|---|
| Temperature | 0.1 | Precise, repeatable summaries |
| Top P | 1 | Output diversity |
| Max Tokens | 2048 | Length of the answer |
| Presence Penalty | 0 | Pushing toward new topics |
| Frequency Penalty | 0 | Cutting repeated words |
Other hosted models worth running through the same test: GPT OSS 120B, Qwen3.7-Plus, Granite 4.1 8B and Kimi K2.6. If one of them follows your format better, you know what to look for in a local download.
LM Studio's own docs are blunt about this: some MCP servers can run arbitrary code, read your local files and use your network connection. Never install one from a source you do not trust. A search server is only a program running on your machine with your permissions.
When a model calls a tool, LM Studio shows a confirmation dialog. You can review and edit the arguments before anything runs, then allow the tool once or permanently. Stay on "allow once" for any server that touches files or the network until you trust it. Permanent permissions are managed in App Settings > Tools & Integrations.
Your mcp.json stores tokens in plain text, so treat the file like a password list:
env and headers over tokens inside URLs, which tend to land in logs.
Most failures fall into five buckets:
npx needs Node.js and uvx needs uv. Run node --version or uv --version in a terminal to confirm.start_index, or raise max_length.💡 Test every new server alone first. Put one entry in the file, ask a question that needs fresh facts, and watch the tool call. Add the next server only after that works.
Once your local setup is searching the web, you will want visuals for the write-ups, tutorials and notes that come out of it: a header for your blog post, a diagram background, a thumbnail for a video walkthrough. That is where PicassoIA fits in.
Try one experiment: write a single photographic prompt, such as "a developer's desk at dawn with a laptop and a notebook of hand-drawn boxes", and run it through three text-to-image models. Flux Krea Dev leans toward images that skip the usual AI look, Seedream 4.5 produces sharp, high-resolution results, and GPT Image 2 follows long, detailed prompts closely. Put the three results side by side and keep the one that fits.
PicassoIA also offers a developer API and MCP connections for its image and video models, so the same workflow can plug into your own tools later. Open PicassoIA, pick a model, and make your first image today.
