Ollama MCP: MCP clients and servers on local models

Parent: Ollama integrations and ecosystem · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-integrations-ecosystem.md

↓ Facts as markdown all context files

ollama launch pi` installs Pi if needed, configures Ollama as a provider including web tools (`@ollama/pi-web-search`), and opens a session; `--config` configures only, `--model qwen3.5:cloud` picks a model. Pi ships four core tools (read, write, edit, bash); everything else comes from extensions. (from docs.ollama.com)

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

MCP Client for Ollama (ollmcp) is a modern, interactive terminal application (TUI) built for harness engineering, connecting local Ollama LLMs to one or more Model Context Protocol (MCP) servers. By fully supporting the core MCP primitives (tools, prompts, and resources), it provides a controlled terminal space where you steer, and the agent executes. With a rich, user-friendly interface, it lets you safely manage your setup in real time with no coding required. Whether you're building, testing, or exploring, this client streamlines your workflow with features like fuzzy autocomplete, advanced [source]
MCPHost is a CLI tool that allows you to interact with various AI models through a unified interface. It supports various tools through MCP servers and can run in both interactive and non-interactive modes. [source]

Structure and components

Ollama MCP Bridge - A Python API layer that sits in front of Ollama, automatically adding tools from multiple MCP servers to every chat request. This project provides a transparent proxy solution that pre-loads all MCP servers at startup and seamlessly integrates their tools into the Ollama API. [source]
Servers added via ollmcp mcp add are always loaded as the base layer. Any flags (--mcp-server, --mcp-server-url, --servers-json, --claude-desktop) add on top. To include servers from Claude Desktop, pass --claude-desktop explicitly. [source]

How it works

The Ollama context window defaults to 4096 tokens across standard models, silently truncating conversation history when inputs exceed runtime memory limits. While tuning the num_ctx parameter allows moderate expansion, inflating the context window on local GPUs rapidly triggers out-of-memory crashes. Connecting your assistant to an intelligent workspace via the Model Context Protocol allows semantic search across large document corpuses without exhausting local video memory. [source]
The configuration also records a defaultProvider. When you run ollmcp with no --provider flag, it loads that provider's profile; a fresh install starts on ollama. Each time you /save-config, the provider you're currently using becomes the new default, so running plain ollmcp resumes wherever you left off. Pass --provider <name> at any time to switch to (and load) a different provider's profile, and --model / --host / --api-key override the saved values for that run. [source]
Breaking change: --auto-discovery / -a has been replaced by --claude-desktop. Additionally, servers added via ollmcp mcp add are now always loaded automatically, they are no longer a fallback that disappears when other flags are used. Claude Desktop servers are never loaded automatically; use --claude-desktop to include them. [source]
Prompts are discovered automatically when you connect to MCP servers. If a server supports prompts, they'll be available immediately in the prompts list and autocomplete. [source]
Resources are discovered automatically when you connect to MCP servers. If a server supports resources, they'll be available immediately in the resources list and @ autocomplete. [source]
This feature dramatically improves the development experience when building and testing MCP servers. [source]
When using GitHub MCP server, make sure to replace "mytoken" with your actual GitHub API token. [source]
The model deepseek-v3.1:671b-cloud only supports tool use when thinking mode is turned off. You can toggle thinking mode in ollmcp by typing either /thinking-mode or /tm. [source]

How-to and procedures

Use ANTHROPIC_AUTH_TOKEN for bearer authentication. Claude settings can override shell variables. Update any base URL or credentials in those settings, then run /status to check the connection. Choose a cloud model that supports tools. Basic chat and file edits work with compatible models. Hosted WebSearch and advanced tool controls are not fully supported. See Anthropic compatibility. [source]
Avoid pip install --break-system-packages ollmcp. It works, but it installs into the system Python and can break packages your OS depends on. [source]
To enable, run ollmcp --install-completion and follow the instructions for your shell [source]

Examples and snippets

```shell theme={"system"} — `codex --profile ollama-launch -c 'web_search="disabled"'` … [source]
```bash theme={"system"} — `pi install npm:@ollama/pi-web-search` … [source]
```typescript — `import { generateText } from 'ai';` … [source]

Problems, failure modes and limitations

Local-model tool calling is less reliable than cloud models: guides report smaller or quantized models break JSON, drop required arguments or ignore tool instructions, and weak tool callers need precise tool names in prompts. This rests on guide-level reports, not benchmarks; the MCPHost-era advice to be specific about tool names reflects the same limit. [source]
ollmcp reads tools, vision and thinking capabilities from Ollama, so a model without tool support is flagged. For non-Ollama (OpenAI-compatible) providers it assumes all three exist and an unsupported model returns an API error; those providers are marked experimental. The README lists gemma4, qwen3.5, lfm2.5-thinking, llama3.2 and mistral as working well. Snapshot: about 830 stars; star counts and versions differ across third-party listings. [source]
ollmcp (jonigl/mcp-client-for-ollama) is a Python 3.11+ terminal client for local Ollama models. It supports MCP tools, prompts and resources, STDIO, SSE and Streamable HTTP transports, multi-server connections, and human-in-the-loop approval of tool calls. Its agent mode loops tool calls up to a limit (default 7); a limit of 1 disables agent mode. [source]
Capability detection limitation: ollmcp only reads real per-model capabilities (tools, vision, thinking) from Ollama. For every non-Ollama provider, all three capabilities are currently assumed available and shown as such in the model list and badges, so a model may be reported as supporting tools, vision, or thinking even when it doesn't. If a model lacks a capability, the provider's API will return an error when you try to use it. [source]
HTTPS certificates for remote MCP servers are verified against your operating system trust store, not the certifi bundle. If an MCP server sits behind a private or corporate CA, or you run ollmcp in a minimal container with no system CA store, the TLS handshake fails with an error that does not mention ollmcp. Point SSL_CERT_FILE (a bundle file) or SSL_CERT_DIR (a directory) at your CA to fix it: [source]
config.yaml ReferenceMigrating Config to YAMLContinue Documentation MCP Serverconfig.json Reference (Deprecated)Context Providers (Deprecated)@Codebase (Deprecated)@Docs (Deprecated) [source]

Comparisons and alternatives

Open WebUI (an independent front-end) documents the failure signature of too little context with native function calling: tool schemas are injected into the prompt, and at 2048 tokens the model can return a blank response or emit a raw tool-call JSON blob instead of calling the tool. Its num_ctx control pre-fills 2048 and overrides the server's OLLAMA_CONTEXT_LENGTH; the fix is to raise context. [source]
What is the default context window in Ollama? Ollama configures a default context window of 4096 tokens across standard model instances. In earlier releases, the default was 2,048 tokens. When an incoming prompt and conversation history exceed this 4,096-token threshold, Ollama silently truncates the earliest messages to fit the budget without raising an error. You can check the current context allocation and memory distribution of active models using the ollama ps command in your terminal. How do I increase the context window in Ollama? You can increase the context window using three methods. [source]
If the model prints raw JSON like {"name": "web_search", ...} in its reply instead of actually running the tool, that's usually the server, not the model — tool calling isn't enabled or the tool-call format isn't parsed. See the per-server fix table in Tool calls appear as text instead of executing (llama.cpp needs --jinja, vLLM needs --enable-auto-tool-choice --tool-call-parser hermes, and so on). [source]

Facts and statements

Claude Code manual setup against local Ollama: export ANTHROPIC_AUTH_TOKEN=ollama, ANTHROPIC_API_KEY="" and ANTHROPIC_BASE_URL=http://localhost:11434, then `claude --model <model>`. For Ollama's cloud without a local install, set ANTHROPIC_BASE_URL=https://ollama.com with ANTHROPIC_AUTH_TOKEN=$OLLAMA_API_KEY. Hosted WebSearch and advanced tool controls are not fully supported through Ollama's Anthropic compatibility, and Claude settings files can override shell variables (check with /status). [source]
ollama launch pi` installs Pi if needed, configures Ollama as a provider including web tools (`@ollama/pi-web-search`), and opens a session; `--config` configures only, `--model qwen3.5:cloud` picks a model. Pi ships four core tools (read, write, edit, bash); everything else comes from extensions. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for local and cloud models and need `ollama signin`; disable with `codex --profile ollama-launch -c 'web_search="disabled"'`. [source]
ollama launch openclaw` installs OpenClaw via npm if missing, shows a security notice, lets the user pick a model, configures the provider, installs the gateway daemon, enables bundled Ollama web search, then opens the OpenClaw TUI. `--config` changes the model without starting; `--model X --yes` is headless and auto-pulls (requires --model). `ollama launch clawdbot` remains an alias (OpenClaw's former name). [source]
Ollama ships its own MCP server example: a Python script (ollama-python examples/web-search-mcp.py) that exposes Ollama web search and fetch to any MCP client. It runs over stdio via uv with OLLAMA_API_KEY in env. Ollama's docs show configs for Cline (mcpServers JSON) and Codex (~/.codex/config.toml [mcp_servers.web_search]), and say Goose connects through its MCP feature. [source]
ollama-js supports tools (`tools`, `tool_name` for results), `think` (boolean or level), `webSearch`/`webFetch` (need an Ollama account and API key), and `abort()`, which cancels all streams on that client; for per-stream cancellation use one client per stream. [source]
ollmcp works with Ollama plus any OpenAI-compatible provider that any-llm exposes. Select one with --provider. Provide the key with --api-key or $OLLMCP_API_KEY (both work for any selected provider) or via the provider's own environment variable shown below. $OLLMCP_API_KEY and the provider-native env vars are never written to disk; only a key passed with --api-key is saved to the config. [source]
1. **Install** — If OpenClaw isn't installed, Ollama prompts to install it via npm 2. **Security** — On the first launch, a security notice explains the risks of tool access 3. **Model** — Pick a model from the selector (see supported local and cloud models [here](https://ollama.com/search)) 4. **Onboarding** — Ollama configures the provider, installs the gateway daemon, sets your model as the primary, and enables OpenClaw's bundled Ollama web search 5. **Gateway** — Starts in the background and opens the OpenClaw TUI [source]
codex --profile ollama-launch -c 'web_search="disabled"' [source]
OpenClaw ships with a bundled Ollama `web_search` provider that lets local or cloud-backed Ollama setups search the web through the configured Ollama host. [source]
☁️ Ollama Cloud Support: Works seamlessly with Ollama Cloud models for tool calling, enabling access to powerful cloud-hosted models while using local MCP tools [source]
MCP Client for Ollama now supports Ollama Cloud models, allowing you to use powerful cloud-hosted models with tool calling capabilities while leveraging your local MCP tools. Cloud models can run without a powerful local GPU, making it possible to access larger models that wouldn't fit on a personal computer. [source]
Ollama’s web search can be integrated with Cline easily using the MCP server configuration. Manage MCP Servers > Configure MCP Servers > Add the following configuration: [source]
MCPHost config uses an mcpServers key (YAML or JSON) with stdio, streamable and inprocess transports (sse only in the legacy format), ${env://VAR} substitution, and per-server allowedTools or excludedTools (one of the two per server). Ollama models must support function calling. [source]
const client = new Ollama(); const results = await client.webSearch("what is ollama?"); console.log(JSON.stringify(results, null, 2)); [source]
const client = new Ollama(); const fetchResult = await client.webFetch("https://ollama.com"); console.log(JSON.stringify(fetchResult, null, 2)); [source]
Local OpenAI-compatible servers (ollama, llamacpp, llamafile, lmstudio, vllm) typically run without an API key, point ollmcp at them with --host. Providers any-llm offers that are not OpenAI-compatible (e.g. anthropic, gemini, mistral, groq, cohere) are not supported yet. [source]
Pi can use web search and fetch tools via the `@ollama/pi-web-search` package. [source]
Ollama can be integrated into most of the tools available either through direct integration of Ollama’s API, Python / JavaScript libraries, OpenAI compatible API, and MCP server integration. Previous [source]
Ollama has no built-in MCP client. Bridges (ollmcp, MCPHost, DIY scripts) discover MCP tools, convert their schemas into the tools format Ollama's chat API accepts, and execute the tool calls the model requests. [source]
MCPHost (mark3labs/mcphost), a Go CLI host that runs Ollama models against MCP servers (flag form -m ollama/qwen2.5:3b, base URL via OLLAMA_HOST), is archived and read-only. The maintainers point to its successor Kit. Older tutorials that install it with go install now point at an unmaintained tool. [source]
The project scope writes a standard .mcp.json file at your project root, compatible with Claude Code and other MCP-aware tools. If the same server name exists in multiple scopes, precedence is local > project > user. [source]
Ollama can integrate with Goose via its MCP feature. [source]
Choose a [cloud model](https://ollama.com/search?c=cloud) that supports tools. Basic chat and file edits work with compatible models. Hosted WebSearch and advanced tool controls are not fully supported. See [Anthropic compatibility](/api/anthropic-compatibility). [source]
Ollama's default context length depends on VRAM: 4k tokens under 24 GiB, 32k at 24-48 GiB, 256k at 48 GiB or more. Ollama recommends at least 64,000 tokens for web search, agents and coding tools; set it with OLLAMA_CONTEXT_LENGTH=64000 ollama serve or the app slider. MCP tool schemas and results compete for this window, so a bridge on a small default context can degrade. [source]
Harness the power of local LLMs with this TUI MCP Client for Ollama. Featuring all core MCP primitives (tools, prompts, resources), agent mode, multi-server, model switching, streaming responses, human-in-the-loop, thinking mode, model params config, system prompts, and saved preferences. [source]
A simple yet powerful Python client for interacting with Model Context Protocol (MCP) servers using Ollama, allowing you to harness local LLMs for advanced tool execution. [source]
/ Ollama Context Window: Default Limits, num_ctx Tuning, and MCP Search [source]
Ollama Context Window: Default Limits, num_ctx Tuning, and MCP Search [source]
Stop forcing massive file corpuses into your local Ollama context window. Index your documents in an intelligent Fast.io workspace, connect your assistant through the remote MCP server, and retrieve exact context chunks on demand. Monthly plans start with a trial of up to 14 days (credit card required); annual plans have no trial. [source]
{ "mcpServers": { "websearch": { "type": "remote", "url": "${env://WEBSEARCH_URL:-https://api.example.com/mcp}", "headers": ["Authorization: Bearer ${env://WEBSEARCH_TOKEN}"] }, "weather": { "type": "remote", "url": "${env://WEATHER_URL:-https://weather-mcp.example.com}" } } } [source]
{ "mcpServers": { "websearch": { "transport": "streamable", "url": "https://api.example.com/mcp", "headers": ["Authorization: Bearer your-api-token"] } } } [source]
mcpServers: filesystem-local: type: "local" command: ["npx", "@modelcontextprotocol/server-filesystem", "/path/to/files"] environment: DEBUG: "true" filesystem-builtin: type: "builtin" name: "fs" options: allowed_directories: ["/tmp", "~/documents"] websearch: type: "remote" url: "https://api.example.com/mcp" [source]
curl https://ollama.com/api/web_search \ --header "Authorization: Bearer $OLLAMA_API_KEY" \ -d '{ "query":"what is ollama?" }' [source]
curl --request POST \ --url https://ollama.com/api/web_fetch \ --header "Authorization: Bearer $OLLAMA_API_KEY" \ --header 'Content-Type: application/json' \ --data '{ "url": "ollama.com" }' [source]
Tool calls: [ToolCall(function=Function(name='web_search', arguments={'max_results': 3, 'query': 'Ollama new engine'}))] Result: results=[WebSearchResult(content='# New model scheduling\n\n## September 23, 2025\n\nOllama now includes a significantly improved model scheduling system. Ahead of running a model, Ollama’s new engine [source]
<Note>Ollama web search for local models requires `ollama signin`.</Note> [source]
ollmcp mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer $YOUR_GITHUB_PAT" ollmcp mcp add --transport stdio playwright npx @playwright/mcp@latest ollmcp mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /allowed-dir1 ~/allowed-dir2 # stdio transport by default ollmcp mcp add --env API_KEY=YOUR_KEY --transport sse my-sse-server http://localhost:8000/sse [source]
ollmcp --host http://localhost:22545 --servers-json /path/to/servers.json [source]
ollmcp --mcp-server-url http://localhost:8000/sse --model qwen2.5:latest [source]
ollmcp --mcp-server-url http://localhost:8000/sse --mcp-server-url http://localhost:9000/mcp [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server-url http://localhost:8000/mcp --model qwen3:1.7b [source]
ollmcp -s /path/to/weather.py -u http://localhost:8000/mcp -m qwen3:1.7b [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server-url http://localhost:8000/mcp --claude-desktop [source]
ollmcp -s /path/to/weather.py -u http://localhost:8000/mcp --claude-desktop [source]
This connects to all servers registered via ollmcp mcp add and uses the model from your saved configuration file, or the first available model in Ollama if none is saved. Pass --claude-desktop to also include servers from Claude Desktop's config. [source]
How to Connect Ollama to External Workspaces via MCP [source]
A CLI host application that enables Large Language Models (LLMs) to interact with external tools through the Model Context Protocol (MCP). Currently supports Claude, OpenAI, Google Gemini, and Ollama models. [source]
mcphost -m ollama/qwen2.5:3b -p "Explain quantum computing" --quiet [source]
mcphost -m ollama/qwen2.5:3b [source]
while True: response = chat( model='qwen3:4b', messages=messages, tools=[web_search, web_fetch], think=True ) if response.message.thinking: print('Thinking: ', response.message.thinking) if response.message.content: print('Content: ', response.message.content) messages.append(response.message) if response.message.tool_calls: print('Tool calls: ', response.message.tool_calls) for tool_call in response.message.tool_calls: function_to_call = available_tools.get(tool_call.function.name) if function_to_call: args = tool_call.function.arguments result = function_to_call(**args) print('Result: ', str [source]
{ "mcpServers": { "web_search_and_fetch": { "type": "stdio", "command": "uv", "args": ["run", "path/to/web-search-mcp.py"], "env": { "OLLAMA_API_KEY": "your_api_key_here" } } } } [source]
[mcp_servers.web_search] command = "uv" args = ["run", "path/to/web-search-mcp.py"] env = { "OLLAMA_API_KEY" = "your_api_key_here" } [source]
🌐 Multi-Server Support: Connect to multiple MCP servers simultaneously [source]
📋 MCP Prompts Support: Browse, invoke, and manage prompts from MCP servers with argument collection, preview, and safe rollback [source]
📦 MCP Resources Support: Browse and read contextual data from MCP servers including files, documents, and structured data [source]
🗣️ Cross-Language Support: Seamlessly work with both Python and JavaScript MCP servers [source]
🔍 Auto-Discovery: Automatically find and use Claude's existing MCP server configurations [source]
🔄 Server Reloading: Hot-reload MCP servers during development without restarting the client [source]
Could not find a version that satisfies the requirement ollmcp (from versions: none) [source]
uv tool install --upgrade ollmcp # recommended, installs the CLI in an isolated environment [source]
On recent Debian/Ubuntu (Python 3.12+), the system pip is intentionally locked to protect OS-managed packages, so pip install ollmcp is blocked. This is a system policy (PEP 668), not an issue with ollmcp. Install it into an isolated environment instead: [source]
python3.11 -m venv ollmcp-env source ollmcp-env/bin/activate python3.11 -m pip install --upgrade ollmcp [source]
ollmcp mcp add --transport http <name> <url> ollmcp mcp add --transport sse <name> <url> [source]
Once you have added some servers, simply running ollmcp will connect to them automatically. [source]
local Current project only No ~/.config/ollmcp/mcp.local.json (keyed by project path) [source]
project Current project only Yes (via VCS) .mcp.json in the project root [source]
--mcp-server, -s: Path to one or more MCP server scripts (.py or .js). Can be specified multiple times. [source]
--mcp-server-url, -u: URL to one or more SSE or Streamable HTTP MCP servers. Can be specified multiple times. See Common MCP endpoint paths for typical endpoints. [source]
--claude-desktop: Load servers from Claude Desktop's config file (~/Library/Application Support/Claude/claude_desktop_config.json). Merged with servers added via ollmcp mcp add and any other flags. [source]
Whatever an MCP server reports is written to ~/.config/ollmcp/logs/<session>/<server>.log, one directory per run, keeping the last 5. Nothing a server prints reaches the screen unless you ask for it — otherwise it would draw over the answer being streamed. [source]
Servers report through two channels: their stderr (only stdio servers, since a remote one runs elsewhere) and MCP log notifications (any server). Both flags only change what you see on screen — the log file gets everything either way: [source]
ollmcp --mcp-server /path/to/weather.py --mcp-server /path/to/filesystem.js [source]
Calls the appropriate MCP server with these arguments (only if approved or HIL is disabled) [source]
MCP Prompts provide reusable, server-defined conversation starters and context templates. Servers can expose prompts with descriptions, required arguments, and pre-formatted messages that help you quickly start specific types of conversations or inject structured context into your chat. [source]
MCP Resources provide access to contextual data exposed by MCP servers-files, documents, structured data, and more. Servers can expose resources with metadata (name, description, MIME type) that you can browse and read into your conversation context. [source]
The /reload-servers command (/rs) is particularly useful during MCP server development. It allows you to reload all connected servers without restarting the entire client application. [source]
Reconnect using the same parameters (servers added via ollmcp mcp add, server paths, config files, --claude-desktop) [source]
Exports your current chat history to a JSON file. You can specify a custom filename or use the default timestamp-based name (e.g., ollmcp_chat_history_2026-01-05_143022.json). Files are saved to ~/.config/ollmcp/history/ directory. The command includes file overwrite protection. [source]
Type / after the prompt symbol to see autocomplete suggestions for available MCP prompts. [source]
Running ollmcp with no flags automatically loads the default configuration from ~/.config/ollmcp/config.json if it exists. [source]
The JSON configuration file supports STDIO, SSE, and Streamable HTTP server types (MCP 1.10.1): [source]
MCP 1.10.1 Transport Support: The client now supports the latest Streamable HTTP transport with improved performance and reliability. If you specify a URL without a type, the client will default to using Streamable HTTP transport. [source]
A common point of confusion is where to store MCP server configuration files and how the TUI's save/load feature is used. Here's a short, practical guide that has helped other users: [source]
The TUI's /save-config / /load-config (or /sc / /lc) commands are intended to save TUI preferences like which tools you enabled, your selected model, thinking mode, display mode, and other client-side settings. They are not required to register MCP server connections with the client. [source]
You can then point ollmcp at that file at startup with -j / --servers-json. [source]
For HTTP-based MCP servers, "type": "http", "streamable-http", and "streamable_http" are all accepted and treated the same way. Also check the Common MCP endpoint paths section below for typical endpoints. [source]
{ "mcpServers": { "github": { "type": "streamable_http", "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer mytoken" } } } } [source]
A short demo (asciicast) that should help anyone reproduce the working setup quickly. This example uses an MCP server example with streamable HTTP protocol usage: [source]
Streamable HTTP MCP servers typically expose the MCP endpoint at /mcp (e.g., https://host/mcp), while SSE servers commonly use /sse (e.g., https://host/sse). Below is an excerpt from the MCP specification (2025-06-18): [source]
The server MUST provide a single HTTP endpoint path (hereafter referred to as the MCP endpoint) that supports both POST and GET methods. For example, this could be a URL like https://example.com/mcp. [source]
You can find more details in the MCP specification version 2025-06-18 - Transports. [source]
You can explore a collection of MCP servers in the official MCP Servers repository. [source]
MCP Server with Streamable HTTP Example - An example MCP server demonstrating the usage of the streamable HTTP protocol. [source]
MCP servers you connect are trusted by you, and their tool/resource responses are treated as untrusted content that reaches the model. See SECURITY.md for the trust model, how indirect prompt injection is handled, and how to report a vulnerability. [source]
A CLI host application that enables Large Language Models (LLMs) to interact with external tools through the Model Context Protocol (MCP). [source]
MCPHost maintains full backward compatibility with the previous configuration format. Note: A recent bug fix improved legacy stdio transport reliability for external MCP servers (Docker, NPX, etc.). [source]
#!/usr/bin/env -S mcphost script --- mcpServers: github: type: "local" command: ["gh", "api"] environment: GITHUB_TOKEN: "${env://GITHUB_TOKEN}" DEBUG: "${env://DEBUG:-false}" [source]
MCPHost's non-interactive mode makes it perfect for automation, scripting, and integration with other tools. [source]
MCPHost can work with any MCP-compliant server. For examples and reference implementations, see the MCP Servers Repository. [source]
Running code and approvals apply_patch toolCode executionDiffsElevated modeExec toolExec approvalsExec approvals — advancedPermission modesSecrets Media and documents Media overviewImage generationMusic generationPDF toolText-to-speech Text to speech Text-to-speech quickstartText-to-speech configurationText-to-speech personasText-to-speech commands and directivesText-to-speech output and Auto-TTS behaviorText-to-speech field referenceText-to-speech agent tool and Gateway RPCVideo generation Tool catalogs and workflows Code Mode Code Mode Code Mode quickstartCode Mode executorsCode Mode configu [source]
🔗 **[MCP Tools Example](../../examples/node/src/mcp-tools-example.ts)** - Model Context Protocol integration [source]
You can enable web search in any MCP client through the Python MCP server. [source]
* Creating custom Agents * Web search * Deep Research * RAG over uploaded documents and connected apps * Connectors to applications like Google Drive, Email, Slack, etc. * MCP and OpenAPI Actions support * Image generation * User/Groups management, RBAC, SSO, etc. [source]

Related concepts

MCP — is a instance of Ollama MCP: MCP clients and servers on local models
ollama — is a related of Ollama MCP: MCP clients and servers on local models
ollama web search — is a dependent of Ollama MCP: MCP clients and servers on local models
tool calling — is a dependent of Ollama MCP: MCP clients and servers on local models
localhost — is a problem of Ollama MCP: MCP clients and servers on local models
OLLAMA_HOST — is a part of Ollama MCP: MCP clients and servers on local models
ollama signin — is a part of Ollama MCP: MCP clients and servers on local models
num_ctx — is a problem of Ollama MCP: MCP clients and servers on local models
ollama launch — is a synonym of Ollama MCP: MCP clients and servers on local models
Codex — is a instance of Ollama MCP: MCP clients and servers on local models
agent harness — is a hypernym of Ollama MCP: MCP clients and servers on local models
openai compatibility — is a dependent of Ollama MCP: MCP clients and servers on local models
OpenClaw — is a instance of Ollama MCP: MCP clients and servers on local models
Goose — is a instance of Ollama MCP: MCP clients and servers on local models
ollama-js — is a instance of Ollama MCP: MCP clients and servers on local models
Claude Code — is a instance of Ollama MCP: MCP clients and servers on local models
anthropic compatibility — is a dependent of Ollama MCP: MCP clients and servers on local models
Hermes — is a instance of Ollama MCP: MCP clients and servers on local models
Pi coding agent — is a instance of Ollama MCP: MCP clients and servers on local models
ollama-python — is a instance of Ollama MCP: MCP clients and servers on local models

Children

No children recorded.

← the whole tree · 3D view· how to read this page