OneAI MCP for AI. Turn messy media and documents into structured data.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
OneAI handles complex text and media processing by exposing specialized Language Skills through your AI agent. Run synchronous pipelines to summarize articles or extract structured entities using `run_pipeline`.
For long documents, audio files, or video analysis, use `run_async_pipeline` to manage stateful workflows; then check the result status with `get_async_task_status`.
It's built for data analysts and developers who need deep NLP capabilities without writing custom models.
What AI agents can do with OneAI Automation
Get async task status
Checks if a long-running OneAI pipeline job is finished and retrieves the final result status.
Run async pipeline
Initiates background processing for large files, audio, or complex data workflows using either content URL or text input.
Run pipeline
Runs a quick, synchronous OneAI language pipeline to summarize text or extract entities immediately in response.
Execute instant NLP tasks like summarizing text or detecting sentiment by calling run_pipeline.
Submit long documents, audio, or video for background processing using run_async_pipeline, which returns a task ID.
Poll the system to see if an asynchronous task finished and retrieve its result via get_async_task_status.
Pull specific pieces of data (like names, dates, or monetary values) from unstructured text input.
Convert spoken word from media files into accurate, searchable plain text.
Ask an AI about this
Waiting for input…
What AI agents can do with OneAI MCP Server: 3 Tools for Media & Text Analysis
Use these three tools to manage the entire lifecycle of content analysis—from starting a massive background job to checking its status and running quick, immediate text skills.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using OneAI on VinkiusGet Async Task Status
Checks if a long-running OneAI pipeline job is finished and retrieves the final result status.
Run Async Pipeline
Initiates background processing for large files, audio, or complex data workflows...
Run Pipeline
Runs a quick, synchronous OneAI language pipeline to summarize text or extract...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The OneAI integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with OneAI, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by OneAI. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 3 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Handling content today means switching between 5 different services., Solved with Vinkius AI Gateway
You pull an article from one source. You copy the raw text into a second service just to detect sentiment. Then, if you want to summarize it, you paste that summary into a third tool. If the content is video, you have to upload it somewhere else first, then run a transcription job in a fourth place. Every single step requires manual copying, pasting, and managing API keys across multiple platforms.
With OneAI MCP Server, your AI client manages this entire sequence. You give the agent the media file or text once, and the server runs all necessary skills—transcription, sentiment check, entity extraction—internally. The result comes back in a single clean package.
OneAI MCP Server: Get everything from audio to structured data.
You don't have to manually transcribe the audio, then copy that text into a summarization tool. You just ask your agent to 'Transcribe this call and summarize key action items.' The server handles the sequence: first, it runs transcription (the async task); second, once complete, it passes the resulting text through the summarizer.
The difference is seamless orchestration. It's one single request that delivers a multi-faceted result—a transcript *and* a summary of action items. That's what this server gives you.
What your AI can actually do with this
You're running into data that's too big or too messy for a quick chat with your agent. This server handles complex media and texts by letting you expose specialized language skills through your AI client. It lets you run deep content analysis without needing to write custom models. You can use it if you're a data analyst or a dev who needs serious NLP power, fast.
Run synchronous analysis: When you need an answer right now, call run_pipeline. This executes instant Natural Language Processing (NLP) tasks directly within your conversation flow. For example, you can instantly summarize lengthy articles, detect shifts in sentiment, or pull out specific data points—structured entities like names, dates, and dollar amounts—from unstructured text input.
You just send the text, call run_pipeline, and get the result back immediately. No waiting.
Process large media files asynchronously: If you're dealing with something that takes time—think massive documents, hours of audio, or full video feeds—you don't want to wait for it to finish in real-time. That’s where run_async_pipeline comes into play. You submit the content using a URL or direct text input, and the system kicks off background processing.
It immediately gives you a task ID so you know the job is running, letting your agent move on while the heavy lifting happens in the background.
This workflow handles everything from transcribing spoken word to analyzing complex multimedia structures. You feed it audio or video content, and it converts that talking into accurate, plain text for further analysis. For documents too long for a single API call, you submit them here; this tool manages the whole lifecycle of processing those big files.
Check job completion status: Since run_async_pipeline just gives you a task ID and doesn't return the final data, you need another function to track it. You check progress using get_async_task_status. You poll this endpoint repeatedly until the job is marked as finished; then, you finally get the full result status and the processed content.
It’s how you manage stateful workflows for massive datasets.
You're not just wrapping up a few simple functions here. This server provides a complete pipeline: you submit big files with run_async_pipeline, track them with get_async_task_status, and when the data is ready, you've got access to deep skills for everything from extracting specific entities (like tracking every mention of a product name or a date range) to summarizing entire books.
It lets your agent handle both the immediate, quick checks and the long-haul processing jobs with total control.
019e5d3e-4485-7304-9cd4-07d0e48f044b 
Here's how it actually works
The bottom line is: your AI client speaks to OneAI via the MCP standard, which handles all the heavy lifting on text, audio, and video processing for you.
Subscribe to the OneAI server and provide your API key.
Tell your AI client (your agent) what content needs processing and which skill to use (e.g., 'Summarize this article').
The agent calls the appropriate tool (run_pipeline for quick tasks, or run_async_pipeline for big jobs) and gets the data back in conversation.
Who is this actually for?
This server is built for developers and data ops engineers. You're the person who gets fed mountains of unstructured content—customer feedback emails, podcast transcripts, long reports—and needs to turn it into clean, actionable data points without writing a dedicated microservice for every job.
Uses run_pipeline to extract structured entities and measure sentiment across thousands of customer support tickets in minutes.
Feeds long articles or podcast audio into the system, using run_async_pipeline to get clean transcripts or summaries that they can publish immediately.
Integrates advanced NLP skills directly into agent workflows for prototyping complex data pipelines without building custom models.
What Changes When You Connect
Process massive files without timeouts. Instead of failing when hitting API limits, use run_async_pipeline for long videos or huge datasets. This offloads the processing and lets your agent track status with get_async_task_status. It keeps the conversation flow stable.
Get immediate insights on text input. Need to know if a paragraph is positive or negative? Call run_pipeline. You get sentiment scores, entity lists, and summaries back instantly—no queueing needed. Perfect for real-time feedback loops.
Handle complex content types (audio/video). Stop treating audio files like simple text blobs. OneAI handles transcription from media sources via specialized skills, letting your agent work with the resulting text transcript as if it were typed out.
Structured data extraction. Don't just get a summary; get structured data. The system can extract specific entities (like product IDs or names) and package them up for easy use in a database or spreadsheet.
Build complex workflows easily. You don't need to manage job queues yourself. run_async_pipeline lets you define multi-step processes—analyze, then summarize, then save—all through one agent call.
See it in action
Analyzing a large batch of customer reviews
The data team gets 500 PDFs of customer feedback. Instead of manually downloading and processing them, the agent calls run_async_pipeline for the batch. Once the task ID is generated, they monitor it with get_async_task_status. When finished, the result gives structured entities (product name, complaint type) from every single document.
Summarizing a lengthy technical article
A developer finds a 30-page whitepaper. They ask their agent to summarize it and extract all key acronyms using run_pipeline. The agent handles the request instantly, providing a concise summary and a bulleted list of extracted entities in the chat window.
Transcribing a recorded sales call
A sales lead records an unedited 20-minute demo. They upload the file and ask their agent to transcribe it using run_async_pipeline. The system processes the audio, returning a text transcript that can be passed back into run_pipeline for sentiment analysis.
Processing multiple related documents
An analyst has three linked reports. Instead of running three separate API calls, they tell their agent to run an async pipeline that processes all three in sequence (e.g., analyze -> summarize -> extract). The agent manages the state transitions for a single complex goal.
The honest tradeoffs
Treating everything as immediate.
The user tries to process a 50MB video file directly with run_pipeline because it's 'simple.' The API times out, and the entire request fails.
For anything over a few megabytes or anything that takes more than two seconds, you must use run_async_pipeline. Always follow up by checking status using get_async_task_status until the job completes.
Ignoring task state.
The user runs run_async_pipeline, gets a Task ID, and then immediately asks for the results. The data isn't ready yet, resulting in an error message.
After calling run_async_pipeline, you must use get_async_task_status repeatedly until the status changes from 'running' to 'completed.' Only then can you expect a result.
Over-complicating simple tasks.
The user tries to run a sentiment check on a small paragraph using the async pipeline when they could just use run_pipeline. This adds unnecessary complexity and overhead.
If the content is small, short, and the required processing is quick (like summarizing or basic extraction), stick to run_pipeline for immediate results.
When It Fits, When It Doesn't
Use this server if your task involves unstructured media (audio/video) or requires complex state management over time. The key differentiator is scale and duration: If the job takes more than a few seconds, use asynchronous tools. For instance, analyzing a 5-minute podcast needs run_async_pipeline followed by get_async_task_status. However, if you're just running a quick sentiment check on a paragraph of text right in the chat—something immediate—then run_pipeline is faster and simpler. Don't try to run small tasks async; that’s over-engineering. If your process requires multiple sequential steps (e.g., Transcribe -> Summarize -> Extract), you need the orchestration power of run_async_pipeline. If all data lives in a simple JSON object passed via text, and it needs instant feedback, stick to run_pipeline.
Questions you might have
How do I run the biggest files with OneAI? Use `run_async_pipeline`? +
You use run_async_pipeline for large media or documents. It doesn't process instantly; it gives you a Task ID that you must monitor using get_async_task_status until it returns 'completed'.
Is `run_pipeline` fast enough for sentiment analysis? +
Yes, run_pipeline is designed for quick tasks. It runs synchronously, giving you immediate results like entity extraction or sentiment scores right away.
What do I use if the audio file is too big? OneAI guide. +
Use run_async_pipeline. Pass the content URL of the audio/video file and request transcription. Remember to check the status using get_async_task_status later.
How do I summarize text quickly with OneAI? +
You use run_pipeline and specify 'summarize' as a skill. Since it's synchronous, you get the summary back in one single response immediately.
What credentials do I need to authenticate and use the `run_pipeline` tool? +
You must provide an OneAI API Key. After subscribing to this server on Vinkius, you enter your unique key directly into your AI agent client for access.
If a long async task fails, how do I troubleshoot it using `get_async_task_status`? +
First, check the status. If the state isn't 'completed', the response payload usually contains an error message or failure code explaining exactly what went wrong with the pipeline.
Can I use `run_async_pipeline` to process multiple data types, like a video URL and raw text input? +
Yep. You pass both the content URL for the media and the raw input text within one request structure. This lets you run combined pipelines.
Is this OneAI server compatible with different types of AI agents? +
Yes, it follows the Model Context Protocol (MCP). Any agent that connects using an MCP-compatible client—like Claude or Cursor—can access tools like run_pipeline.
How can I summarize a text and extract entities at the same time? +
Use the run_pipeline tool. Provide your text in the input field and define the steps as a JSON array like [{"skill":"summarize"}, {"skill":"entities"}].
What should I use for processing large audio files? +
Use run_async_pipeline. You can provide a content_url for the audio file and set the steps to include the transcribe skill. This starts a background task.
How do I know when my asynchronous processing is finished? +
Use the get_async_task_status tool with the task_id returned by the async pipeline. It will provide the current status and the final results once completed.
We've already built the connector for OneAI. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 3 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.