--- title: "What Is Generative AI API Integration? Models, Prompts, Embeddings and Agents Across Providers" img: https://s3.us-east-2.amazonaws.com/unified-article-images/what_is_generative_ai_api_integration_models_prompts_embeddings_and_agents_across_providers-icon.png date: 2026-02-12T19:00:00.000Z updated: 2026-10-20T19:02:02.154Z readingTime: 9 tag: Product description: Unified.to's Generative AI API lists models, sends prompts and creates embeddings with one request shape across 52 AI integrations, including OpenAI, Anthropic Claude, Google Gemini, Cohere and Mistral AI, using your customer's own model account. url: "https://unified.to/blog/what_is_generative_ai_api_integration_models_prompts_embeddings_and_agents_across_providers" --- # What Is Generative AI API Integration? Models, Prompts, Embeddings and Agents Across Providers [Unified.to](http://unified.to/)'s [Generative AI API](/genai) lists models, sends prompts and creates embeddings with one request shape across 52 AI integrations, including OpenAI, Anthropic Claude, Google Gemini, Cohere and Mistral AI, using your customer's own model account. It's for product teams whose customers bring their own model provider. [Unified.to](http://unified.to/) doesn't store prompts or responses, and it doesn't route requests: your app picks the connection and model for each call. To let a model read and act on a customer's SaaS apps, pass a [Unified [MCP](/mcp)](/mcp) URL in the prompt's `mcp_url` field, on integrations that support it. Providers change model names, feature flags differ, and teams end up maintaining multiple SDKs, model lists and request shapes to keep inference working across OpenAI, Anthropic, Gemini and others. This guide covers what a generative AI API does, the objects in [Unified.to](http://unified.to/)'s Generative AI API, how requests behave, and how it fits with [Unified.to](http://unified.to/)'s Storage, KMS, Repository, Messaging and MCP APIs. ## Why is supporting multiple LLM providers hard? Generative AI providers such as OpenAI, Anthropic Claude, Google Gemini, Cohere, MistralAI, Groq, Hugging Face, Azure OpenAI, DeepSeek, and others each ship their own APIs, auth patterns, and request/response formats. Products that support multiple model providers usually run into: - Different chat message formats and response shapes - Provider-specific model catalogs and capability flags (temperature, max token behavior, tool support) - Separate embedding endpoints with inconsistent vector formats and dimensionality options - Provider-specific failure modes when a model is unavailable or rate-limited A Generative AI API provides a category-scoped interface for model discovery, prompt execution, and embedding generation across providers. ## What Is a Generative AI API? A generative AI API is an HTTP interface that lets an application: - List available models and model capabilities - Send prompts/messages to an LLM and receive responses - Generate embeddings for text inputs It focuses on model calls and embedding generation. It is not a chat product, a vector database, or a place to store prompt history. [Unified.to](http://unified.to/)'s Generative AI API also covers coding-agent tasks, agents, provider skills and memory stores, on supported integrations (see the objects below). ## Which AI integrations does [Unified.to](http://unified.to/)'s Generative AI API support? It supports 52 integrations, on every plan, Grow included. LLM providers include OpenAI, Anthropic Claude, Google Gemini, Azure OpenAI, Cohere, Mistral AI, Groq, Hugging Face, DeepSeek, AnyScale and [X.ai](http://x.ai/) Grok (beta). The category also covers cloud model platforms such as Amazon Bedrock, Google Vertex AI and Microsoft Foundry, gateways such as OpenRouter and Vercel AI Gateway, coding agents such as Cursor and Devin, and memory stores such as Mem0, all in beta (as of 19 October 2026). Which objects each integration supports is listed on its integration page in [Unified.to](http://unified.to/)'s docs. ## How does the Generative AI API differ from [Unified.to](http://unified.to/)'s other APIs and Unified MCP? The Generative AI API calls models. [Unified.to](http://unified.to/)'s other APIs read and write your customers' SaaS records, and Unified MCP turns those APIs into tools a model can call. [Unified.to](http://unified.to/) keeps each category in its own API: - GenAI handles models, prompts and embeddings across LLM integrations, plus coding-agent tasks, agents, organizations, provider skills and memories on supported integrations. - Storage handles files and folders (download URLs, hierarchical traversal, metadata). - KMS handles spaces, pages, and comments in knowledge platforms (Confluence, Notion, Guru, etc.). - Repository handles orgs, repos, branches, commits, and pull requests in version control systems. - Messaging handles channels, messages, and events in chat platforms. - Unified MCP turns [Unified.to](http://unified.to/) integrations into tools an LLM can call to read and write your customers' records, on supported integrations. GenAI can be used alongside these categories (for example, embedding KMS pages or summarizing storage files), but those objects remain in their own APIs. ## Does [Unified.to](http://unified.to/) store prompts, responses or embeddings? No. Each GenAI request passes through to the selected model provider at request time. [Unified.to](http://unified.to/) runs no sync jobs and keeps no copy of prompt inputs, outputs or embeddings. Connection credentials (your customer's model API key) are encrypted at rest, and the provider's own retention policy still applies. ### Stateless execution for Prompt and Embedding Prompts and embeddings are one-shot operations: - There is no prompt ID. - There are no list or retrieve endpoints for prompts or embeddings. - If you need history, you include it yourself in the messages array or store it in your system. Models are different: they can be listed and retrieved as catalog metadata. Task, Agent, Organization and Memory are different again: they're records in the provider's own system, with list and get endpoints on supported integrations. ## What objects does [Unified.to](http://unified.to/)'s Generative AI API include? Eight, as of 19 October 2026. Each object has one schema; which fields an integration supports is listed on its integration page. | Object | Methods | What it is | Example integrations | | ------------ | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | | Model | List, Get (Get on some integrations) | A provider's models and flags (`has_temperature`, `has_vision`, `max_tokens`) | OpenAI, Anthropic Claude, Google Gemini, Groq | | Prompt | Create | One model call: `messages` in, `responses` and `tokens_used` out (typed `answers` for decision models); optional `mcp_url` | OpenAI, Anthropic Claude, Cohere, Mistral AI | | Embedding | Create | Vectors for text, with `dimension` and `type` options | OpenAI, Cohere, Google Gemini, Azure OpenAI (not Anthropic Claude) | | Task | List, Get, Create, Update, Remove (varies) | A coding-agent or browser-agent run | OpenAI, GitHub; Cursor, Devin, Google Jules, Browserbase (beta) | | Agent | List, Get, Create, Update, Remove (varies) | A reusable agent configuration | OpenAI; Anthropic Claude Agents, Devin (beta) | | Organization | List, Get, Create, Update, Remove (varies) | An organization on the provider's side (name, description, active status) | OpenAI; Anthropic Claude Agents, Codegen (beta) | | Skill | List, Get, Remove | The provider's own skills a prompt can use (`skill_ids`) | OpenAI, Anthropic Claude, Mistral AI, [X.ai](http://x.ai/) Grok (beta) | | Memory | List, Get, Create, Update, Remove (varies by integration) | Memory stores, folders and memories for an end user | Anthropic Claude; Mem0, Amazon Bedrock AgentCore (beta) | Provider skills here are the model provider's own, not [Unified.to](http://unified.to/)'s Agent Skills for coding agents. ### Model Models represent provider model metadata. Key fields include: - id, name, description - max_tokens - has_temperature - web_url - has_vision, has_questions (where the integration reports them) Models are read-only. Your application lists models to discover what's available and to understand capability flags (for example, whether temperature is supported). ### Prompt Prompts represent a single inference request and its response. Key request fields include: - model_id - messages[] - temperature (when supported by the model) - max_tokens (not on every integration; check the model's `max_tokens` first) Key response fields include: - responses[] - tokens_used MCP and skill fields on the Prompt object, on supported integrations (as of 19 October 2026): - mcp_url: a remote MCP server URL the model provider calls during the prompt (Anthropic Claude, Cohere, Google Gemini, Groq, OpenAI, [X.ai](http://x.ai/) Grok (beta)) - mcp_authorization_token and mcp_deferred_tools (Anthropic Claude and OpenAI) - skill_ids: provider skills from the Skill object (Anthropic Claude and OpenAI) These let the model provider call Unified MCP tools during one prompt. The Generative AI API itself doesn't create conversation threads or keep state between prompts. ### Embedding Embeddings represent a single embedding request and its returned vector. Embedding is on supported integrations, including OpenAI, Cohere, Google Gemini, Mistral AI and Azure OpenAI; Anthropic Claude has none (as of 19 October 2026). Key fields include: - model_id - content - dimension - type - embeddings - tokens_used Embeddings are returned to your application. [Unified.to](http://unified.to/) doesn't provide a vector index or vector search layer. If you need retrieval, you store vectors in your own database and handle similarity search there. ## How does a model call read and act on your customers' SaaS data? Through Unified MCP. Set the prompt's `mcp_url` to a Unified MCP server URL for one customer connection, and the model provider calls Unified MCP's tools during that prompt: reading records and, on supported integrations, creating or updating them. `mcp_url` is on Anthropic Claude, Cohere, Google Gemini, Groq, OpenAI and [X.ai](http://x.ai/) Grok (beta); Anthropic Claude and OpenAI also take `mcp_authorization_token` and `mcp_deferred_tools` (as of 19 October 2026). The Generative AI API reads no SaaS data itself. For setup, see [Unified MCP installation](https://docs.unified.to/mcp/installation) and [how to connect LLMs to SaaS data with Unified MCP](https://unified.to/blog/how_to_connect_llms_to_real_time_saas_data_with_unified_mcp_server). ## Do GenAI objects link to records in [Unified.to](http://unified.to/)'s other APIs? Almost never. Model, Prompt and Embedding don't reference Storage files, KMS pages, Repository objects, CRM records or tickets. The one documented cross-reference is Task `user_id` (an HR employee); Task `repo_url` is a plain URL, not a Repository object ID. - Model identifiers map to LLM providers' model naming. - Prompts reference a model_id and carry messages and responses for that request only. - Embeddings reference a model_id and return vectors for that request only. If you want to connect GenAI outputs to other systems, you do it explicitly in your application (for example, store an embedding alongside the KMS page ID you generated it from). ## Does the Generative AI API send webhooks? Only for agent runs. Prompts, embeddings and models emit no webhooks. The Task object has change events on supported integrations: native on OpenAI, and virtual on Anthropic Claude Agents, Browserbase, GitHub, opencode and TinyFish (the Agent object also has virtual webhooks on Browserbase); all but OpenAI and GitHub are in beta (as of 20 October 2026). Virtual webhooks check at an interval you set, as often as every minute on paid plans, and a check that finds nothing isn't billed. - No webhooks are emitted for Prompt or Embedding objects. - There is nothing to poll for prompts or embeddings because there are no list endpoints. - To detect model catalogue changes, list models again and compare; the models list takes no filters such as `updated_gte` (as of 19 October 2026). ## What do teams build with [Unified.to](http://unified.to/)'s Generative AI API? Multi-provider model calls with fallback, model comparison, embedding pipelines, coding-agent task dispatch, and agents that act on SaaS data when paired with Unified MCP. ### Multi-model inference Send the same request shape to any connected provider, so provider fallback and controlled rollout across models are a few lines of logic in your app rather than a rewrite per vendor. ### Model comparison Send the same prompt to multiple model IDs and compare responses, token usage, and output differences. Useful for evaluations and regression testing. ### Embedding generation for retrieval Create embeddings with the provider you choose (on supported integrations, including OpenAI, Cohere, Google Gemini and Mistral AI; Anthropic Claude has none), store the vectors in your own vector database, and read source content from [Unified.to](http://unified.to/)'s Storage, KMS or other APIs. Records read at request time reflect the source app at that moment; stored vectors are as current as your last re-embedding, which change events can trigger on supported integrations. See the [RAG guide](https://docs.unified.to/guides/retrieval_augmented_generation_rag). ### Dispatching coding-agent tasks Create, list and track tasks on coding agents such as Cursor, Devin, Google Jules, Codegen, opencode and Anthropic Claude Agents (beta), and GitHub, through the Task object, and send a follow-up prompt with a task update. What a running task does with a follow-up is up to each vendor. ### Prompt testing and management Standardize how your team defines prompt payloads and model selection logic so prompt changes don't require per-provider rewrites. ## How does [Unified.to](http://unified.to/) handle prompt data? Prompts and responses pass through without being stored. GenAI requests and responses can include sensitive content, so [Unified.to](http://unified.to/) keeps no data store of prompt content. - Requests pass through to the provider at request time. - Prompt payloads, responses, and embedding vectors are returned to your application. - If you need persistence, you store the data in your own infrastructure. Provider retention policies still apply at the model provider layer. Your compliance posture depends on both your own retention decisions and the provider configuration you choose. ## Should you build multi-provider LLM support in-house or use [Unified.to](http://unified.to/)? If you only ever call one provider, its own SDK is simpler. Once customers bring different providers, every SDK, auth pattern, request shape and model catalogue is code you maintain; [Unified.to](http://unified.to/)'s Generative AI API replaces those with one request shape per object. ### Building in-house - Multiple provider SDKs and auth patterns - Different request/response shapes per provider - Separate model catalogs and capability flags - Extra work to implement routing and fallback consistently ### Using [Unified.to](http://unified.to/)'s Generative AI API - One API surface for models, prompts, embeddings, agent tasks and memories - Unified request shapes across providers - Clear separation from content categories (Storage, KMS, Repository) and execution tooling (MCP) - Direct control over what your application stores ## What are the best practices for GenAI integrations? Treat calls as stateless, keep persistence in your own systems, and let model metadata drive feature flags: - Treat Prompt and Embedding as execution calls, not stored objects. - Persist only what you need (and decide retention explicitly). - Use Model metadata to drive feature flags (temperature support, token limits). - Store embeddings in your own vector store, keep model_id and dimension alongside them. - Keep category boundaries clean: retrieve content via Storage/KMS/Repository, generate via GenAI, execute tools via MCP. ## Build GenAI integrations that stay portable If your product supports multiple model providers, you need consistent request shapes, predictable model discovery, and a clean separation between model execution and the data your application stores. [Unified.to](http://unified.to/)'s Generative AI API gives you one schema for models, prompts and embeddings across 52 AI integrations, plus agent tasks and memories on supported integrations, with no prompt data stored. → [Start your 30-day free trial](https://app.unified.to/login) → [Book a demo](https://calendly.com/d/cph9-g8n-jzg/connect-with-unified)