# OneAI MCP

> 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.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** nlp, transcription, summarization, text-analysis, ai-skills

## Description

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.

## Tools

### 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.

## Prompt Examples

**Prompt:** 
```
Summarize this article and extract entities: [text]
```

**Response:** 
```
I've processed the text using `run_pipeline`. Here is the summary: [Summary]. I also found these entities: [Entities].
```

**Prompt:** 
```
Transcribe the audio at this URL: https://example.com/audio.mp3
```

**Response:** 
```
I've started an asynchronous transcription task using `run_async_pipeline`. Your Task ID is `task_123`. You can check its status later.
```

**Prompt:** 
```
Check the status of OneAI task task_123.
```

**Response:** 
```
I've retrieved the status using `get_async_task_status`. The task is 'completed'. Here is the transcribed text: '...'
```

## Capabilities

### Run synchronous analysis
Execute instant NLP tasks like summarizing text or detecting sentiment by calling `run_pipeline`.

### Process large media files asynchronously
Submit long documents, audio, or video for background processing using `run_async_pipeline`, which returns a task ID.

### Check job completion status
Poll the system to see if an asynchronous task finished and retrieve its result via `get_async_task_status`.

### Extract structured entities
Pull specific pieces of data (like names, dates, or monetary values) from unstructured text input.

### Transcribe audio and video content
Convert spoken word from media files into accurate, searchable plain text.

## Use Cases

### 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.

## Benefits

- **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.

## How It 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.

1. Subscribe to the OneAI server and provide your API key.
2. Tell your AI client (your agent) what content needs processing and which skill to use (e.g., 'Summarize this article').
3. 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.

## Frequently Asked Questions

**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.