# Eden AI MCP > Eden AI routes requests across over 100 AI models, letting you use multiple providers—like OpenAI, Anthropic, or Google—from one place. It handles everything from standard chat completions to specialized tasks like OCR and translating images, all without juggling dozens of API keys. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** llm-orchestration, multi-model-api, ocr, embeddings, ai-routing ## Description Managing a multi-model stack is usually a nightmare; every time you want to add a new feature, you write custom code for OpenAI, then rewrite it again for Claude, then update the whole thing for Google. This MCP solves that by providing one unified endpoint for everything. You stop managing API keys and start building workflows. Need to chat with GPT-4 but use Anthropic's model for summarization? No problem. It handles the routing automatically. Beyond standard conversations, you can execute specialized tasks like converting audio to text or generating images using dedicated tools. Plus, it keeps track of your usage so you know exactly what you’re spending. When you connect this MCP via Vinkius, you get a single access point to run complex pipelines regardless of which provider owns the underlying AI brain. ## Tools ### check_credits Retrieves your current credit balance for Eden AI, letting you know if you have enough funds to run a job. ### list_files Lists every file you have uploaded to the MCP's storage, helping you track what context is available. ### chat_completions Creates a standard conversational response by routing the request to the desired AI model or using smart routing logic. ### create_custom_token Generates a unique API token that can be restricted by specific usage limits or constraints. ### create_embedding Converts blocks of text into numerical vectors, which are necessary for semantic search and retrieval augmented generation (RAG). ### create_stateful_response Creates a chat history that the MCP stores on its side, allowing conversations to continue over multiple calls. ### delete_files Removes files you previously uploaded from Eden AI's persistent storage for cleanup purposes. ### get_async_job Checks the status and retrieves results from a job that ran in the background, like large-scale audio processing. ### list_embedding_models Provides a list of all available models designed specifically for creating text embeddings across various providers. ### monitor_consumption Provides detailed data on your API usage and costs, so you can track spending over time. ### universal_ai_async Starts a background job for complex tasks like Speech-to-Text or large image generation that needs time to complete. ### universal_ai_sync Executes instant, specialized tasks like translating text or running OCR directly when you need an immediate result. ### upload_file Uploads a document or file to the MCP's persistent storage so your AI agent can reference it later. ## Prompt Examples **Prompt:** ``` Create a chat completion using openai/gpt-4o via Eden AI. ``` **Response:** ``` I've initiated the chat completion with GPT-4o. The model responded: 'Hello! How can I assist you today with Eden AI's unified interface?' ``` **Prompt:** ``` Generate an image of a futuristic city using image/generation/openai/dall-e-3. ``` **Response:** ``` Executing the image generation task... I've successfully generated the image of a futuristic city via DALL-E 3. You can access the result at the provided URL. ``` **Prompt:** ``` Check my current Eden AI credit balance. ``` **Response:** ``` I've checked your account. You currently have 45.50 credits remaining in your Eden AI balance. ``` ## Capabilities ### Run multi-model chats You can initiate conversations and specify which AI model should handle the response without changing your code. ### Process specialized media tasks It executes dedicated, non-chat jobs like Optical Character Recognition (OCR), image generation, or translating text across formats. ### Store and manage files You can upload documents to persistent storage and list them later so your AI agent has context for its tasks. ### Create vector representations The MCP converts raw text into numerical vectors, which is essential for building advanced search or retrieval systems. ### Monitor usage and tokens You check your remaining credits and monitor overall API consumption to keep a tight grip on costs. ## Use Cases ### Analyzing a mixed-format corporate presentation A user uploads a PDF report using `upload_file`. The agent then runs OCR on it via `universal_ai_sync`, creates embeddings with `create_embedding` to index the text, and finally generates a summary chat response using `chat_completions` based only on that indexed data. ### Building an automated customer support triage bot The agent receives a voice note from a user. It uses `universal_ai_async` to transcribe the audio, then sends the resulting text and file context via `create_stateful_response`. The chat model can then analyze the intent without needing multiple API keys for transcription and chat. ### Testing LLM performance before launch A development team needs to compare GPT-4’s summarization against Claude 3.5's summary output. They use `chat_completions` multiple times in a single test run, guaranteeing they are comparing apples to apples using the same routing mechanism. ### Generating and indexing knowledge bases A data scientist uploads dozens of PDFs. They list them with `list_files`, then use `create_embedding` on chunks of text from those files, building a reliable vector index for semantic search. ## Benefits - Don't write different integration code just to support Claude or Google. The `chat_completions` tool handles routing, meaning your application logic stays clean no matter which provider powers the chat. - You get full control over resource costs by checking credits first. Use `check_credits` and `monitor_consumption` together so you never run a job only to hit an unexpected bill. - It simplifies specialized tasks. Instead of connecting separate services for OCR, translation, or image generation, the `universal_ai_sync` tool handles them all under one roof. - The MCP manages your data context. Use `upload_file` and `list_files` to give your agent specific documents it needs to read before running a summary task. - Handle heavy lifting without blocking your user interface. The `universal_ai_async` tool kicks off long jobs (like transcribing hours of audio) and you just poll the status with `get_async_job` later. ## How It Works The bottom line is you talk to one address, and it figures out where the answer needs to come from. 1. Subscribe to this MCP and provide your unique Eden AI API Key. 2. Your agent calls the unified endpoint, specifying the required model type (e.g., GPT-4 or Claude 3) and task (e.g., chat completion). 3. The MCP routes the request internally, executes the job with the correct provider, and returns the structured result to your client. ## Frequently Asked Questions **How do I use `chat_completions` if I want to switch between GPT-4 and Claude?** You specify the desired provider or model within your call parameters for `chat_completions`. The MCP handles the routing, so you don't need separate code blocks for each LLM. **Does using `universal_ai_async` mean my job runs forever?** No. You use `get_async_job` to check on its status and retrieve the final result once it's done processing, so you know exactly when the background task finished. **`create_embedding` only works with text input?** No. While `list_embedding_models` shows available options, `create_embedding` handles converting structured data and text into vectors for use in search applications. **What's the difference between `universal_ai_sync` and `chat_completions`?** Sync tools handle specialized tasks like OCR or translation immediately. Chat completions are designed specifically for conversational turns, maintaining history via `create_stateful_response`. **I want to improve security; how do I use `create_custom_token`?** You create a custom token with specific constraints. This limits the token's scope and permissions, which is great for reducing risk if credentials get compromised. **After I upload files using `upload_file`, how do I delete them from storage?** You must explicitly call `delete_files`. This tool removes the data from Eden AI's persistent storage, ensuring you manage file lifecycle and clean up old context. **What is the difference between regular chat completions and using `create_stateful_response`?** The stateful response stores conversation history on the server. This means your agent doesn't have to resend the full transcript every time; it just references the session ID. **If I use `check_credits`, can I also track my spending over a period of time?** Yes, you run `monitor_consumption`. This tool gives you historical data and detailed cost breakdowns, helping you plan your API usage across different models. **How can I use Eden AI's smart routing to find the best model for a chat?** Simply use the `chat_completions` tool and set the `model` parameter to `@edenai`. This will automatically route your request to the most suitable provider based on performance and cost. **How do I handle long-running AI tasks like Speech-to-Text?** Use the `universal_ai_async` tool to start the job. You will receive a job ID which you can then use with the `get_async_job` tool to check the status and retrieve the final results once finished. **Can I manage the files I upload for AI processing?** Yes. You can use `upload_file` to send data, `list_files` to see everything in your storage, and `delete_files` to remove them when they are no longer needed.