# Kieai

```json
{
  "name": "Kieai",
  "slug": "kieai",
  "url": "https://composio.dev/toolkits/kieai",
  "markdown_url": "https://composio.dev/toolkits/kieai.md",
  "logo_url": "https://logos.composio.dev/api/kieai",
  "categories": [
    "ai & machine learning"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-06-18T09:36:45.037Z"
}
```

![Kieai logo](https://logos.composio.dev/api/kieai)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Kieai MCP or direct API to generate videos, create images, compose music, run LLM prompts, and track AI generation jobs through natural language.

## Summary

Kieai is an AI API platform for video, image, music, and LLM generation.
Use it to access models like Veo3, Kling, Runway, Luma, Flux, and Suno with pay-as-you-go pricing.

## Categories

- ai & machine learning

## Toolkit Details

- Tools: 35

## Images

- Logo: https://logos.composio.dev/api/kieai

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Kieai.
  - Setup:
    - Configure Api Key credentials for Kieai.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Generate Veo3 product teaser video
- Create Flux images for campaign
- Compose Suno jingle for launch

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `KIEAI_ADD_INSTRUMENTAL` | Add Instrumental to Vocal Track | Add AI-generated instrumental accompaniment to an existing vocal track. Use when you need to generate instrumental music to accompany a vocal recording, allowing customization of style, mood, and creative parameters. The task completion will be notified via the callback URL. |
| `KIEAI_ADD_VOCALS` | Add vocals to instrumental | Add AI-generated vocals to an existing instrumental music track. Use this action when you want to add singing or vocal tracks to accompany an existing instrumental audio file. The action submits a vocal generation task and returns a task ID that can be used to track the generation status. This action is asynchronous - use the returned taskId to poll for completion via the callback URL or check task status separately. |
| `KIEAI_CREATE_MARKET_TASK` | Create Market Task | Create a task for unified model access through the Market API. Submit tasks to any supported AI model (Kling, Sora2, Hailuo, Wan, Google, Ideogram, ElevenLabs, etc.) through a single unified interface. Specify the model and its input parameters, then receive a task ID to poll for completion. Use this action when you need to generate content (text-to-speech, images, video, etc.) via Kie.ai's unified Market API with access to multiple AI providers through one endpoint. |
| `KIEAI_CREATE_MUSIC_VIDEO` | Create music video from generated audio | Create a music video (MP4) combining generated music with visuals. Use this action when you need to generate an MP4 music video from previously generated music tracks. The action requires a task ID from the music generation process and an audio ID for the specific track. The video generation is async - results are delivered to the specified callback URL. Once the video is ready, the callback URL receives a POST request with: - code: 0 for success, 500 for error - data.task_id: The unique task identifier - data.video_url: The video URL (valid for 14 days) |
| `KIEAI_EXECUTE_GPT_CODEX` | Execute GPT Codex | Access GPT Codex capabilities through the KIE.AI Market API. Use when you need to leverage advanced code understanding and generation abilities via the Codex model for tasks such as code completion, refactoring, bug explanation, or general programming assistance. The action supports both single-turn queries (plain string input) and multi-turn conversations (list of message objects with roles). Optional features include configurable reasoning depth, web search for up-to-date information, and function calling for structured tool use. Note: Web search and function tools are mutually exclusive and cannot be used together in the same request. When streaming is enabled (stream=True), the response is delivered incrementally via SSE events. |
| `KIEAI_EXTEND_MUSIC` | Extend Suno Music | Extend an existing Suno music track with additional AI-generated content. Use this action when you need to extend or modify existing music by creating a continuation or variation based on the provided audio ID and parameters. The action submits a generation request and returns a task ID that can be used to track the progress via callback. Note: When defaultParamFlag is false, provide custom parameters (prompt, styleWeight, etc.) to control the extension behavior. When defaultParamFlag is true, provide continueAt, style, and title instead. |
| `KIEAI_EXTEND_VEO_VIDEO` | Extend Veo Video | Extend an existing Veo3.1 video with additional AI-generated content. Continues a previously generated video by adding new frames that seamlessly follow the original video. Use this action when you need to extend a video generated through the Veo3.1 API with additional content. After submission, poll 'Get Veo Video Details' using the returned taskId to check extension status until completion. Note: Video extension is asynchronous. You will receive a taskId in the response that must be used to poll for completion status. Only videos generated through the Veo3.1 API can be extended, and videos generated after 1080P cannot be extended. |
| `KIEAI_GENERATE_ALEPH_VIDEO` | Generate Aleph Video | Generate AI video using Runway Aleph model from text prompts. Creates high-quality video content based on detailed text descriptions, optionally with reference video or image inputs. Use when you need to generate a video from a text description (text-to-video) or transform an existing video with AI (video-to-video). After submission, poll 'Get Aleph Video Details' using the returned taskId to check generation status until completion. Note: Video generation is asynchronous. You will receive a taskId in the response that must be used to poll for completion status. Generated videos are available for 14 days after completion. |
| `KIEAI_GENERATE_COVER` | Generate Music Cover | Generate a personalized cover version of a song using AI. Use when you want to create AI-generated variations or custom covers of existing music tracks. Each music task can only generate one Cover. Cover images are typically valid for 14 days. The action returns a task ID that can be used to track the generation progress. The callback URL will receive a POST request when cover generation completes, containing the task ID and generated image URLs. |
| `KIEAI_GENERATE_FLUX_KONTEXT_IMAGE` | Generate Flux Kontext Image | Generate or edit images using the Flux Kontext model. Supports both text-to-image generation and image editing modes. Use when you need to create new images from text descriptions or edit existing images with AI-powered transformations. The API returns a task ID that can be used to poll for completion status. Generated images expire after 14 days. |
| `KIEAI_GENERATE_GPT4O_IMAGE` | Generate GPT-4o Image | Generate images using the GPT-4o image generation model. Creates AI-generated images from text prompts. Use when you need to create new images from text descriptions. The API returns a task ID that should be polled using the 'Get GPT-4o Image Details' action to check completion status and retrieve the generated image URLs. Generated images are stored for 14 days and download URLs are valid for 20 minutes. |
| `KIEAI_GENERATE_LYRICS` | Generate AI Lyrics | Generate creative lyrics using AI. Creates new song lyrics based on the provided prompt, style, and other parameters. Use when you want to create AI-generated song lyrics for a music track or need creative lyrical content. The action returns a task ID that can be used to track the generation progress. When generation completes, the callback URL will receive a POST request with the generated lyrics data including 2-3 lyric variations with titles. Note: Generated lyrics are retained for 14 days. |
| `KIEAI_GENERATE_MIDI` | Generate MIDI | Generate MIDI file from audio or music generation. Converts audio tracks to MIDI format for use in digital audio workstations. Use when you need to convert separated audio stems (from vocal/instrument separation) into MIDI files for further music production workflows. This action requires a valid taskId from a prior vocal separation operation and a callback URL to receive completion notifications. Prerequisites: Must first use the Vocal & Instrument Stem Separation API to separate audio before generating MIDI. |
| `KIEAI_GENERATE_MUSIC_STYLE` | Generate Music Style | Boost or enhance music style parameters for improved music generation. Use when you need to generate or enhance music style descriptions to influence AI music generation. The content field should contain a concise description of the desired music style. Returns a task ID that can be used to track the generation progress and credits information for the request. |
| `KIEAI_GENERATE_SOUNDS` | Generate Sounds | Generate sound effects or audio clips based on a text description. Creates AI-generated audio sounds with configurable parameters like tempo, key, and looping. Use this action when you need to generate sound effects, short audio clips, or ambient sounds for projects. The action submits a generation request and returns a task ID that can be used to track progress via polling or callback. Supports BPM control (1-300), musical key selection (e.g., Cm, D#m, Any), looping option, and optional lyrics capture. The generated sounds are typically valid for 14 days. |
| `KIEAI_GENERATE_TIMESTAMPED_LYRICS` | Get Timestamped Lyrics | Retrieve synchronized lyrics with timestamps for a music track. Gets lyrics with time markers for karaoke-style synchronization. Use this action when you need to display synchronized lyrics for a generated music track or implement karaoke-style highlighting. |
| `KIEAI_GENERATE_VEO_VIDEO` | Generate Veo Video | Generate AI video using Google Veo3.1 model from text prompts or images. Creates high-quality video content based on detailed text descriptions or by animating provided images. Use when you need to generate a video from a text description (text-to-video) or animate one or more reference images (image-to-video). After submission, poll 'Get Veo Video Details' using the returned taskId to check generation status until completion. Note: Video generation is asynchronous. You will receive a taskId in the response that must be used to poll for completion status. |
| `KIEAI_GET_ACCOUNT_CREDITS` | Get Account Credits | Retrieve the current credit balance for your KIE.AI account. Use when you need to check available credits before making API requests or monitor account usage. This action is read-only and does not modify any data. |
| `KIEAI_GET_ALEPH_VIDEO_DETAILS` | Get Aleph Video Details | Retrieves details and status of an Aleph video generation task. Returns task information including current status (generating, success, or failed) and video URLs when complete. Use this action when checking the progress of a video generation task or retrieving the final video output after completion. This is a polling endpoint—call periodically until task completion. Note: Generated videos are only available for 14 days. The resultVideoUrl and resultImageUrl are only present when successFlag is 1 (success). |
| `KIEAI_GET_COVER_DETAILS` | Get Cover Details | Get the status and details of a cover song generation task. Use when you need to check the progress of a cover generation task or retrieve the generated cover image URLs after completion. The response includes the task status (pending, generating, success, or failed), creation and completion timestamps, and the generated cover image URLs when the task is complete. Poll this endpoint to track task progress until successFlag indicates completion (1) or failure (3). |
| `KIEAI_GET_FLUX_KONTEXT_IMAGE_DETAILS` | Get Flux Kontext Image Details | Retrieve the status and details of a Flux Kontext image generation task. Use this action when you need to check the progress of an image generation task, get the generated image URL upon completion, or diagnose why a task failed. The task status (successFlag) indicates: - 0 (GENERATING): Task is still processing - 1 (SUCCESS): Task completed with image URL in response field - 2 (CREATE_TASK_FAILED): Task creation failed - 3 (GENERATE_FAILED): Task created but image generation failed |
| `KIEAI_GET_GPT4O_IMAGE_DETAILS` | Get GPT-4o Image Details | Retrieves details and status of a GPT-4o image generation task. Returns task information including current status (generating, success, or failed) and image URLs when complete. Use when checking the progress of an image generation task or retrieving the final image output after completion. This is a polling endpoint—call periodically until task completion. Note: Image generation tasks return URLs that are available only for a limited time. Download images promptly after task completion. |
| `KIEAI_GET_LYRICS_DETAILS` | Get Lyrics Details | Retrieves the status and details of a lyrics generation task. Returns the generated lyrics text when the task is complete. Use this action to poll for lyrics generation results after submitting a lyrics generation request. The task status can be: PENDING (waiting), SUCCESS (complete), or various error states. If the status is SUCCESS, check the response.data.response.data field for the generated lyrics. |
| `KIEAI_GET_MARKET_TASK_DETAILS` | Get Market Task Details | Retrieves the status and details of a Market API task by its task ID. Use when you need to check the progress or outcome of a previously submitted task, such as after creating a task with a Market API action or when polling for completion. This action queries the unified Market API job status endpoint. |
| `KIEAI_GET_MIDI_DETAILS` | Get MIDI Details | Retrieves details and status of a MIDI generation task. Returns MIDI data including detected instruments, notes, timing, and velocity when the task is complete. Use when checking the progress of a MIDI generation task or retrieving the final MIDI output after completion. This is a polling endpoint—call periodically until task completion. Note: MIDI records are retained for 14 days. When using vocal separation with type 'split_stem', the midiData field may be empty. Check errorCode and errorMessage fields when successFlag indicates failure. |
| `KIEAI_GET_MUSIC_DETAILS` | Get Music Details | Get the status and details of a Suno music generation task including generated audio URLs and metadata. Use this action when you need to check the completion status of a music generation task, retrieve audio URLs for download or playback, or monitor the progress of a previously submitted generation request. Poll this endpoint until status reaches SUCCESS or an error state. Note that instrumental tracks will not include lyrics data. |
| `KIEAI_GET_MUSIC_VIDEO_DETAILS` | Get Music Video Details | Retrieves details and status of a music video generation task. Returns task information including current status (PENDING, SUCCESS, or failed) and video URL when complete. Use when checking the progress of a music video generation task or retrieving the final video output after completion. This is a polling endpoint—call periodically until task completion. Note: Video records are only available within 14 days after generation. |
| `KIEAI_GET_RUNWAY_VIDEO_DETAILS` | Get Runway Video Details | Retrieves details and status of a Runway video generation task. Returns comprehensive task information including the current state (wait, queueing, generating, success, or fail) and video URLs when the task is complete. Use this action when checking the progress of a Runway video generation task or retrieving the final video output after completion. This is a polling endpoint—call periodically until the task reaches a terminal state. Note: Video URLs returned in the response are valid for 14 days. For extension tasks, the parentTaskId field indicates the original generation task. |
| `KIEAI_GET_TIMESTAMPED_LYRICS_STATUS` | Get Timestamped Lyrics Status | Retrieve the status and results of a timestamped lyrics generation task. Use this action when you need to check the completion status of a previously initiated timestamped lyrics generation request, or to retrieve the lyrics data with word-level timestamps for karaoke-style synchronization. Note: The data field will be populated once the task completes successfully. |
| `KIEAI_GET_VEO1080P_VIDEO` | Get Veo 1080p Video | Retrieve the 1080p high-definition version of a completed Veo3.1 video generation. Use when you need to download the HD version of a video after the initial generation is complete. The 1080p conversion typically takes 1-3 minutes after the original generation completes. Note: Poll this endpoint every 20-30 seconds until the video is ready. If the task is still processing, the API will return an appropriate error. The original generation task must be successful before requesting the 1080p version. |
| `KIEAI_GET_VEO4K_VIDEO` | Get Veo 4K Video | Retrieve the 4K ultra-high-definition version of a completed Veo3.1 video generation. Use when you need to download the 4K version of a video after the original generation is complete. The 4K conversion typically takes longer than the 1080p conversion (approximately 2-5 minutes) after the original generation completes. Use this action when you have a completed video generation task and want to access the premium 4K quality output. Poll this endpoint every 30-45 seconds until the video is ready. The original generation task must be successful before requesting the 4K version. |
| `KIEAI_GET_VEO_VIDEO_DETAILS` | Get Veo Video Details | Retrieves details and status of a Veo3.1 video generation task. Returns task information including current status (generating, success, or failed) and video URLs when complete. Use when checking the progress of a video generation task or retrieving the final video output after completion. This is a polling endpoint—call periodically until task completion. Note: Videos generated with fallback model cannot be upgraded to 1080P. Records are only available within 14 days. |
| `KIEAI_GET_WAV_DETAILS` | Get WAV Details | Retrieves the status and download URL for a WAV conversion task. Returns task information including current status (PENDING, SUCCESS, or failed) and the WAV audio URL when complete. Use when checking the progress of a WAV conversion task or retrieving the final audio output after completion. This is a polling endpoint—call periodically until task completion. Note: WAV files are retained for 14 days. The audioWavUrl is only available when successFlag is SUCCESS. |
| `KIEAI_REPLACE_MUSIC_SECTION` | Replace Music Section | Replace a specific section of a Suno music track with new AI-generated content. Use this action when you need to modify a portion of an existing music track by replacing it with newly generated content while preserving the rest of the track. The action submits a replacement request and returns a task ID that can be used to track progress via callback. Constraints: - The replacement duration (infillEndS - infillStartS) must be between 6 and 60 seconds. - The replacement cannot exceed 50% of the original music's total duration. - This action is irreversible once submitted. |
| `KIEAI_SEPARATE_VOCALS` | Separate Vocals from Audio | Separates vocals and instruments from an audio track using AI-powered audio source separation. Use this action when you need to extract vocals from an instrumental track, create karaoke versions of songs, isolate vocals for remixing, or generate instrumentals for sampling. The action supports two separation modes: 'separate_vocal' (2 stems - vocal and instrumental) and 'split_stem' (up to 12 stems). Results are delivered via callback URL, and audio URLs remain accessible for 14 days. Note: Re-submitting the same track deducts credits again with no caching. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Kieai Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Kieai actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'Generate a 5-second cinematic Veo3 video of a neon city skyline at night'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'Generate a 5-second cinematic Veo3 video of a neon city skyline at night'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK for Python or TypeScript
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Initialize Client and Create Tool Router Session

Import and initialize the Composio client, then create a Tool Router session for Kieai
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });
const session = await composio.create('your-user-id');
console.log(`Tool Router session created: ${session.mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent (Anthropic Claude or Mastra)
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Kieai tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('Create a Flux image of a futuristic sneaker on a white studio background')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: session.mcp.url,
    headers: {
      'x-api-key': 'your-composio-api-key',
    },
  },
});

const tools = await client.tools();
const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{
    role: 'user',
    content: 'Create a Flux image of a futuristic sneaker on a white studio background'
  }],
  maxSteps: 5,
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Kieai Integration

- Supports both Kieai MCP and direct API based integrations
- Structured, LLM-friendly schemas so agents can request video, image, music, and LLM generations reliably
- Rich coverage for creating media jobs, checking generation status, and using Kieai outputs in downstream workflows

### 2. Managed API Key Auth

- Kieai uses API key authentication, so your agents don't need hard-coded keys in prompts or source code
- Use auth_configs.create() to define the Kieai auth setup and connected_accounts.link() to connect each user's Kieai account
- Composio handles secure credential storage and API request handling for your Kieai tools

### 3. Agent Optimized Design

- Tools are shaped for language models, so agents can understand when to generate a Veo3 video, Flux image, or Suno music track
- Clear inputs and outputs reduce tool-call guesswork for creative AI tasks
- Comprehensive execution logs show what the agent created, when it ran, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Kieai generation tools
- Scoped, least-privilege access to Kieai resources instead of broad shared credentials
- Full audit trail of agent actions across video, image, music, and LLM requests

## Use Kieai with any AI Agent Framework

Choose a framework you want to connect Kieai with:

- [Claude Cowork](https://composio.dev/toolkits/kieai/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/kieai/framework/codex)

## Related Toolkits

- [Composio](https://composio.dev/toolkits/composio) - Composio is an integration platform that connects AI agents with hundreds of business tools. It streamlines authentication and lets you trigger actions across services—no custom code needed.
- [Composio search](https://composio.dev/toolkits/composio_search) - Composio search is a unified web search toolkit spanning travel, e-commerce, news, financial markets, images, and more. It lets you and your apps tap into up-to-date web data from a single, easy-to-integrate service.
- [Perplexityai](https://composio.dev/toolkits/perplexityai) - Perplexityai delivers natural, conversational AI models for generating human-like text. Instantly get context-aware, high-quality responses for chat, search, or complex workflows.
- [Browser tool](https://composio.dev/toolkits/browser_tool) - Browser tool is a virtual browser integration that lets AI agents interact with the web programmatically. It enables automated browsing, scraping, and action-taking from any AI workflow.
- [Ai ml api](https://composio.dev/toolkits/ai_ml_api) - Ai ml api is a suite of AI/ML models for natural language and image tasks. It provides fast, scalable access to advanced AI capabilities for your apps and workflows.
- [Aivoov](https://composio.dev/toolkits/aivoov) - Aivoov is an AI-powered text-to-speech platform offering 1,000+ voices in over 150 languages. Instantly turn written content into natural, human-like audio for any application.
- [All images ai](https://composio.dev/toolkits/all_images_ai) - All-Images.ai is an AI-powered image generation and management platform. It helps you create, search, and organize images effortlessly with advanced AI capabilities.
- [Anthropic administrator](https://composio.dev/toolkits/anthropic_administrator) - Anthropic administrator is an API for managing Anthropic organizational resources like members, workspaces, and API keys. It helps you automate admin tasks and streamline resource management across your Anthropic organization.
- [Api labz](https://composio.dev/toolkits/api_labz) - Api labz is a platform offering a suite of AI-driven APIs and workflow tools. It helps developers automate tasks and build smarter, more efficient applications.
- [Apipie ai](https://composio.dev/toolkits/apipie_ai) - Apipie ai is an AI model aggregator offering a single API for accessing top AI models from multiple providers. It helps developers build cost-efficient, latency-optimized AI solutions without juggling multiple integrations.
- [Astica ai](https://composio.dev/toolkits/astica_ai) - Astica ai provides APIs for computer vision, NLP, and voice synthesis. Integrate advanced AI features into your app with a single API key.
- [Bigml](https://composio.dev/toolkits/bigml) - BigML is a machine learning platform that lets you build, train, and deploy predictive models from your data. Its intuitive interface and robust API make machine learning accessible and efficient.
- [Botbaba](https://composio.dev/toolkits/botbaba) - Botbaba is a platform for building, managing, and deploying conversational AI chatbots across messaging channels. It streamlines chatbot automation, making it easier to integrate AI into customer interactions.
- [Botpress](https://composio.dev/toolkits/botpress) - Botpress is an open-source platform for building, deploying, and managing chatbots. It helps teams automate conversations and deliver rich, interactive messaging experiences.
- [Chatbotkit](https://composio.dev/toolkits/chatbotkit) - Chatbotkit is a platform for building and managing AI-powered chatbots using robust APIs and SDKs. It lets you easily add conversational AI to your apps for better user engagement.
- [Cody](https://composio.dev/toolkits/cody) - Cody is an AI assistant built for businesses, trained on your company's knowledge and data. It delivers instant answers and insights, tailored for your team.
- [Context7 MCP](https://composio.dev/toolkits/context7_mcp) - Context7 MCP delivers live, version-specific code docs and examples right from the source. It helps developers and AI agents instantly retrieve authoritative programming info—no more out-of-date docs.
- [Customgpt](https://composio.dev/toolkits/customgpt) - CustomGPT.ai lets you build and deploy chatbots tailored to your own data and business needs. Get precise and context-aware AI conversations without writing code.
- [Datarobot](https://composio.dev/toolkits/datarobot) - Datarobot is a machine learning platform that automates model development, deployment, and monitoring. It empowers organizations to quickly gain predictive insights from large datasets.
- [Deepgram](https://composio.dev/toolkits/deepgram) - Deepgram is an AI-powered speech recognition platform for accurate audio transcription and understanding. It enables fast, scalable speech-to-text with advanced audio intelligence features.

## Frequently Asked Questions

### Do I need my own developer credentials to use Kieai with Composio?

Yes, Kieai requires you to configure your own API key. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)