# Open WebUI MCP for AI Agents AI Agent Connect

> Open WebUI MCP lets you manage your local and cloud LLM infrastructure directly from your favorite AI client. It handles model listing, knowledge base management, and direct Ollama interaction. Use it to organize your documents, manage collections, and switch between models without leaving your workspace.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_YhwRL8adKsCUXpVOwybG0l7vG8Iky4FGyj9DhmOn/ai-agent-connect
- **Tags:** llm-management, rag, model-inference, self-hosted, chat-interface, automation

## Description

Imagine you're running a fleet of local models and a growing library of documents. Usually, you're jumping between different tabs, checking if a model is loaded, and manually uploading files to different folders to build your knowledge base. This Connector changes that. It puts the controls for your Open WebUI instance right into your primary chat interface. Instead of navigating a web dashboard, you can just tell your agent to find a specific model, start a new conversation, or add a new document to a specific collection. It handles the heavy lifting of data processing, letting you see when your files are ready to be queried. Whether you're managing a complex local setup or a distributed cloud environment, this connection gives you a unified way to orchestrate your entire AI stack. It's one of the many high-quality integrations available in the Vinkius catalog that actually simplifies the way you interact with self-hosted infrastructure. You get to stay in your flow while the agent handles the backend chores of model switching and data ingestion. You can check if your documents are finished indexing or quickly pull in content from a website to update your knowledge base without ever leaving your workspace. It turns a fragmented workflow into a single, cohesive experience where your agent acts as the operator for your entire setup.

## Tools

### add_file_to_collection
Put a specific file into a knowledge collection. This helps keep your data organized by topic.

### chat_completed
Run outlet filters for a finished conversation. It helps with post-chat processing and logging.

### ollama_generate
Get a completion directly from Ollama. This is the fastest way to run local inference.

### ollama_tags
List all the tags and models in your Ollama setup. It helps you keep track of your local library.

### process_web_url
Turn a website link into a knowledge collection. This is the quickest way to add web data to your system.

### chat_completions
Get a response using an OpenAI-compatible endpoint. This works well for standard chat tasks.

### create_new_chat
Start a new conversation with a backend-controlled flow. It ensures every new chat gets a unique ID.

### get_file_status
Check if your document is finished processing. This is useful for knowing when your data is ready.

### list_models
See every model available in your instance. It lets you quickly identify which models are ready to use.

### ollama_embed
Generate embeddings using the Ollama API. Use this for creating vector representations of your data.

### send_message
Generate a response using an Anthropic-compatible endpoint. It's great for specific message-based workflows.

### upload_file
Send a file to your vector database for RAG. This is how you get your local documents into the system.

## Prompt Examples

**Prompt:** 
```
What models do I have available right now?
```

**Response:** 
```
I've checked your Open WebUI instance. You have the following models ready to go:

| Model Name | Type |
| :--- | :--- |
| **llama3:latest** | Ollama |
| **gpt-4o** | OpenAI |
| **custom-function** | Open WebUI |

Would you like to start a new chat with one of these?
```

**Prompt:** 
```
Add this URL https://docs.example.com to my 'Technical Docs' collection.
```

**Response:** 
```
I've started processing that URL for you. It's being scraped and added to your 'Technical Docs' collection now. I'll let you know once the ingestion is complete.
```

**Prompt:** 
```
Give me a quick summary of the 'Research_Paper.pdf' using the llama3 model.
```

**Response:** 
```
Using the llama3 model to analyze your document. Here is the summary:

* **Key Finding:** The study shows a 20% increase in efficiency...
* **Methodology:** A randomized controlled trial...
* **Conclusion:** Further testing is required.

Would you like me to dig deeper into any of these points?
```

## Capabilities

### List all available models
See every model in your instance so you can choose the right one for the task.

### Upload files to a vector database
Send documents to your system for immediate use in your knowledge base.

### Process web URLs into collections
Turn a website link into a searchable knowledge set with a single command.

### Create backend-controlled chats
Start new conversations that follow your specific backend rules and IDs.

### Generate completions via Ollama
Run local inference directly through your Ollama setup for private processing.

### Check document ingestion status
Verify that your files are finished processing and ready to be queried.

## Use Cases

### Building a private knowledge base
A researcher wants to ingest 50 PDFs. They ask the agent to upload_file and add_file_to_collection to a 'Research' folder.

### Rapid model testing
A developer wants to see which model handles a specific task best. They use list_models and ollama_generate to compare outputs.

### Automated web scraping
A content manager wants to feed a blog post into their RAG. They ask the agent to process_web_url into a 'News' collection.

### Managing production chats
An admin needs to create new sessions for users. They use create_new_chat to ensure every chat has a unique ID.

## Benefits

- Manage models without leaving your IDE by using list_models to see what's available instantly.
- Build your RAG library faster by using upload_file and process_web_url to ingest data with single commands.
- Keep your knowledge organized by using add_file_to_collection to group documents by project or topic.
- Stay updated on data readiness by checking get_file_status so you don't query incomplete files.
- Run local inference directly through ollama_generate for a faster, more private experience.
- Standardize your chat flow using create_new_chat to ensure consistent backend behavior for every session.

## How It Works

The bottom line is you get a direct remote control for your Open WebUI instance from inside your AI chat.

1. Subscribe to the Connector and get your Open WebUI Base URL and API Key.
2. Enter your credentials into your AI client's MCP connection settings.
3. Start asking your agent to list models, upload files, or manage your collections.

## Frequently Asked Questions

**Can I use the Open WebUI MCP to manage my local models?**
Yes. This Connector connects to your Open WebUI instance, allowing your AI agent to list, tag, and generate completions for models running locally via Ollama or other providers.

**How do I add documents to my RAG system using this?**
You can simply ask your agent to upload a file or provide a web URL. The Connector handles the extraction and adds the content to your specified knowledge collections automatically.

**Does the Open WebUI MCP work with Claude or Cursor?**
Yes, it works with any MCP-compatible client. You just need to provide your Open WebUI Base URL and API key in the connection settings.

**Can I check if my files are finished processing?**
Yes. You can ask your agent to check the status of a specific file, and it will tell you if the document is ready to be used as RAG context.

**Is it possible to create new chats automatically?**
Yes. The Connector includes a tool to create new chats that handles the backend-controlled flow and ensures every new session gets its own unique ID.

**Can I use this to manage multiple different AI models?**
Yes. It can fetch and list all models available in your instance, including those from Ollama, OpenAI, and custom Open WebUI functions.

**How can I check if a model is available in my Open WebUI instance?**
You can use the `list_models` tool. It will return a complete list of all configured models, including those from Ollama, OpenAI, and internal Open WebUI functions.

**Can I add a website to my RAG collection using just a URL?**
Yes! Use the `process_web_url` tool. Provide the URL and the target collection name, and the server will scrape and index the content for you.

**How do I know when my uploaded file is ready for querying?**
After using `upload_file`, you can check the ingestion progress by calling `get_file_status` with the returned File ID. It will tell you if the status is 'completed' or 'pending'.