> ## Documentation Index
> Fetch the complete documentation index at: https://docs.core-ai.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Kimi Provider

> Create and configure the Kimi provider for Moonshot AI chat completions

## Overview

The Kimi provider connects to the [Moonshot AI Kimi API](https://platform.kimi.ai/) — an OpenAI-compatible Chat Completions endpoint. Use your Kimi API key and supported model IDs such as `kimi-k2.7-code`.

## Installation

```bash theme={null}
npm install @core-ai/kimi
```

## createKimi()

Create a Kimi provider instance.

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});
```

### Options

<ParamField path="apiKey" type="string" optional>
  Your Kimi (Moonshot AI) API key.
</ParamField>

<ParamField path="baseURL" type="string" optional>
  Custom API base URL. Defaults to `https://api.moonshot.ai/v1`.
</ParamField>

<ParamField path="client" type="OpenAI" optional>
  Provide your own configured OpenAI SDK client instance.
</ParamField>

### Returns

`KimiProvider` with method `chatModel()`.

## Supported models

* **kimi-k2.7-code** — coding-focused agentic model with always-on thinking and preserved reasoning
* **kimi-k2.7-code-highspeed** — same model with higher output speed

## Capabilities

| Feature                                               | Support                                            |
| ----------------------------------------------------- | -------------------------------------------------- |
| Chat Completion                                       | Yes                                                |
| Streaming                                             | Yes                                                |
| Function Calling                                      | Yes                                                |
| Vision                                                | Yes                                                |
| Reasoning                                             | Yes (always on for K2.7 Code)                      |
| Structured Output (`generateObject` / `streamObject`) | Yes (JSON Mode with client-side schema validation) |
| Embeddings                                            | No                                                 |
| Image Generation                                      | No                                                 |

## Examples

### Basic chat

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';
import { generate } from '@core-ai/core-ai';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});

const model = kimi.chatModel('kimi-k2.7-code');

const result = await generate({
  model,
  messages: [{ role: 'user', content: 'Implement quicksort in TypeScript.' }],
  maxTokens: 32768,
});

console.log(result.content);
```

### Streaming

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';
import { stream } from '@core-ai/core-ai';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});

const model = kimi.chatModel('kimi-k2.7-code');

const chatStream = await stream({
  model,
  messages: [{ role: 'user', content: 'Explain dependency injection.' }],
});

for await (const event of chatStream) {
  if (event.type === 'reasoning-delta') {
    process.stdout.write(event.text);
  }
  if (event.type === 'text-delta') {
    process.stdout.write(event.text);
  }
}
```

### Multi-turn reasoning preservation

Kimi K2.7 Code requires historical `reasoning_content` in assistant messages. core-ai preserves this automatically when you use `resultToMessage()`:

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';
import { generate, resultToMessage } from '@core-ai/core-ai';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const messages = [{ role: 'user', content: 'Plan a refactor.' }];
const firstResult = await generate({ model, messages, maxTokens: 32768 });

const followUp = await generate({
  model,
  messages: [
    ...messages,
    resultToMessage(firstResult),
    { role: 'user', content: 'Now implement step one.' },
  ],
  maxTokens: 32768,
});
```

## Fixed sampling constraints

For `kimi-k2.7-code` and `kimi-k2.7-code-highspeed`, Moonshot fixes sampling parameters server-side:

* `temperature`: `1.0`
* `top_p`: `0.95`
* penalties: `0.0`

Do not pass custom `temperature` or `topP` values. The provider validates these locally and omits fixed parameters from outbound requests.

<Warning>
  Kimi K2.7 Code always runs in thinking mode. Thinking cannot be disabled for this model family.
</Warning>

## Structured output

`generateObject()` and `streamObject()` use Moonshot JSON Mode (`response_format: { type: 'json_object' }`) and validate the returned JSON with your Zod schema.

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';
import { generateObject } from '@core-ai/core-ai';
import { z } from 'zod';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const result = await generateObject({
  model,
  messages: [{ role: 'user', content: 'Return the weather for Berlin.' }],
  schema: z.object({
    city: z.string(),
    temperatureC: z.number(),
  }),
  schemaName: 'weather_schema',
});

console.log(result.object);
```

You can also use JSON Mode directly with `generate()`:

```typescript theme={null}
import { createKimi } from '@core-ai/kimi';
import { generate } from '@core-ai/core-ai';
import { z } from 'zod';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const schema = z.object({ city: z.string(), temperatureC: z.number() });

const result = await generate({
  model,
  messages: [
    {
      role: 'user',
      content:
        'Return only valid JSON matching {"city": string, "temperatureC": number}.',
    },
  ],
  providerOptions: {
    kimi: {
      responseFormat: { type: 'json_object' },
    },
  },
});

const object = schema.parse(JSON.parse(result.content ?? '{}'));
```

Forced tool choice via `toolChoice: { type: 'tool', toolName }` is rejected on K2.7 Code models because Moonshot does not allow forced tool selection while thinking is always enabled.

## Provider-specific options

Pass Kimi-specific options via `providerOptions.kimi`:

```typescript theme={null}
await generate({
  model: kimi.chatModel('kimi-k2.7-code'),
  messages: [{ role: 'user', content: 'Hello!' }],
  providerOptions: {
    kimi: {
      parallelToolCalls: true,
      responseFormat: { type: 'json_object' },
      stopSequences: ['END'],
      seed: 42,
    },
  },
});
```

Available fields: `parallelToolCalls`, `responseFormat`, `stopSequences`, `seed`, `user`.

## Error handling

```typescript theme={null}
import { ProviderError } from '@core-ai/core-ai';

try {
  const result = await generate({
    model: kimi.chatModel('kimi-k2.7-code'),
    messages: [{ role: 'user', content: 'Hello!' }],
  });
} catch (error) {
  if (error instanceof ProviderError) {
    console.error('Kimi API error:', error.message);
    console.error('Status:', error.statusCode);
  }
}
```

## Related

<CardGroup cols={2}>
  <Card title="OpenAI Compat Provider" icon="message" href="/api/providers/openai">
    OpenAI Chat Completions compatibility reference
  </Card>

  <Card title="core-ai Functions" icon="function" href="/api/core/generate">
    Learn about generate, stream, and more
  </Card>
</CardGroup>