canonical: https://jentic.com/apis/inflection.ai/main

# Inflection AI API

Inflection AI provides an API for its language models, covering chat completions, embeddings, and inference. Applications send messages to generate model responses, create vector embeddings for text, and read discovery configurations that describe available options. Legacy inference endpoints, including a streaming variant, remain available for existing integrations.

## For AI agents

Lets an AI agent call Inflection AI language models for chat completions and embeddings, read discovery configurations, and run inference requests.

## Scope

Does not handle fine-tuning, model hosting, or billing. Use it for chat completions, embeddings, and inference only.

## Capabilities

- Generate chat completions from Inflection AI language models
- Create vector embeddings for text
- Retrieve chat attributes for a conversation
- Read discovery configurations for available options
- Run legacy inference requests, including streaming

## Use cases

### Conversational responses

A product needs model-generated replies inside a chat experience. Inflection AI accepts a sequence of messages and returns a chat completion, so an application can power a conversational feature without hosting a model. Streaming inference is available where a product wants responses to appear incrementally.

Example prompt: Send a conversation history and return the model's chat completion

### Text embeddings for search

A retrieval feature needs vector representations of text. Inflection AI creates embeddings for supplied text, letting an application build semantic search or clustering over its own documents. The embeddings endpoint pairs with a vector store the product already runs.

Example prompt: Create embeddings for a set of documents and return the vectors for indexing

### AI agent model access

An AI agent needs a language model it can call under governed access. The agent sends prompts for chat completions or embeddings and reads discovery configurations to pick options, with each model operation gated behind what the operator has allowed. The token stays outside the agent's own context.

Example prompt: Read the discovery configurations, then send a prompt to the selected model for a completion

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/chat/completions` | Create a chat completion |
| POST | `/v1/embeddings` | Create embeddings for text |
| POST | `/v1/chat/attributes` | Get chat attributes |
| GET | `/v1/discovery/configs` | List discovery configurations |
| POST | `/external/api/inference` | Run a legacy inference request |
| GET | `/status` | Check service status |

## Key resources

- **Chat** — Create chat completions and read chat attributes
- **Embeddings** — Create vector embeddings for text
- **Discovery** — List discovery configurations for available options
- **Inference** — Run legacy inference requests, including a streaming variant

## Why Jentic

- **Setup:** Wiring Inflection AI by hand means provisioning a bearer token, choosing between the current chat endpoints and the legacy inference paths, and handling streaming responses. Install Jentic One once, import the API from the Jentic API Directory, and store the credential once for your agent to reuse.
- **Permission scoping:** Scope your agent to the operations it needs, such as chat completions or embeddings, and withhold the rest. You decide which operations are callable, so an agent can generate text without gaining access to every endpoint.
- **Credential handling:** Your Inflection AI token is stored once, encrypted, by your own Jentic One instance and injected only at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents find Inflection AI through Jentic's intent search: a query such as 'generate a chat completion' matches the chat and embeddings operations, which the agent then calls with your stored credential.

## Related APIs

- **OpenAI** — Chat completions, embeddings, and a broad model family
- **Mistral AI** — Open-weight and hosted language models for chat and embeddings
- **Cohere** — Embeddings, rerank, and language models for retrieval

## FAQ

### What can an AI agent do with the Inflection AI API?

An agent can generate chat completions, create text embeddings, read chat attributes and discovery configurations, and run inference requests including a streaming variant. It provides governed access to Inflection AI language models.

### How does the Inflection AI API authenticate?

It authenticates with a bearer token on requests to its model endpoints, while the service status endpoint is open. Jentic injects the token at execution time so it stays out of the agent's context.

### Can I limit what my agent is allowed to do with the Inflection AI API?

Yes. Your Jentic One instance decides which operations an agent may call, so you can allow chat completions while withholding embeddings or the legacy inference endpoints. Nothing outside the operations you allow is reachable.

### What operations does the Inflection AI API offer?

It offers chat completions, text embeddings, chat attributes, and discovery configurations, plus legacy inference endpoints including a streaming variant for existing integrations.

### How do I connect the Inflection AI API to my AI agent with Jentic?

Install Jentic One with its setup script, import the Inflection AI API from the Jentic API Directory, and store your token once. Your agent can then call the chat and embeddings operations you allow.