# DeepSeek Provider

DeepSeek provides advanced reasoning models with exceptional performance at competitive prices. Known for strong math, coding, and logical reasoning capabilities.

## Setup

### Installation

```go
import (
    "github.com/digitallysavvy/go-ai/pkg/ai"
    "github.com/digitallysavvy/go-ai/pkg/providers/deepseek"
)
```

### Configuration

```go
provider := deepseek.New(deepseek.Config{
    APIKey: os.Getenv("DEEPSEEK_API_KEY"),
})

model, err := provider.LanguageModel("deepseek-chat")
if err != nil {
    log.Fatal(err)
}
```

### Get API Key

1. Sign up at [platform.deepseek.com](https://platform.deepseek.com)
2. Create API key
3. Set environment variable:

```bash
export DEEPSEEK_API_KEY=sk-...
```

## Available Models

### Language Models

| Model ID | Context | Input Price | Output Price | Best For |
|----------|---------|-------------|--------------|----------|
| deepseek-chat | 64K | $0.27/1M | $1.10/1M | General purpose |
| deepseek-reasoner | 64K | $0.55/1M | $2.19/1M | Complex reasoning |
| deepseek-coder | 128K | $0.14/1M | $0.28/1M | Code generation |

## Provider-Specific Features

### Reasoning Mode

Extended thinking for complex problems:

```go
model, err := provider.LanguageModel("deepseek-reasoner")

result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
    Model:  model,
    Prompt: "Solve this logic puzzle: Three friends...",
})

// Response includes reasoning process
if result.ReasoningText != "" {
    fmt.Println("Reasoning:", result.ReasoningText)
}
```

### Code Generation

Optimized for programming tasks:

```go
codeModel, err := provider.LanguageModel("deepseek-coder")

result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
    Model:  codeModel,
    Prompt: "Implement a thread-safe LRU cache in Go",
})
```

### Vision (DeepSeek V4)

`deepseek-v4*` models return `SupportsImageInput() == true`; image file
parts are sent to the API instead of being rejected with an error, as on
earlier DeepSeek models:

```go
result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
    Model: model, // a deepseek-v4* model
    Messages: []types.Message{{
        Role: types.RoleUser,
        Content: []types.ContentPart{
            types.TextContent{Text: "Describe this image"},
            types.FileContent{MediaType: "image/png", URL: "https://example.com/image.png"},
        },
    }},
})
```

### Files API

`provider.Files()` returns a `provider.FilesAPI`, or use the higher-level
`ai.UploadFile` helper, to upload files that are later referenced from chat
messages by `file_id`:

```go
uploaded, err := ai.UploadFile(ctx, ai.UploadFileOptions{
    API:       provider,
    Data:      fileBytes,
    MediaType: "application/pdf",
})
if err != nil {
    log.Fatal(err)
}

result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
    Model: model,
    Messages: []types.Message{{
        Role: types.RoleUser,
        Content: []types.ContentPart{
            types.TextContent{Text: "Summarize this document."},
            types.FileContent{FileData: types.FileData{
                Type:      types.FileDataTypeReference,
                Reference: uploaded.ProviderReference,
            }},
        },
    }},
})
```

DeepSeek has no batch API and no additional Files methods beyond upload —
this matches the upstream TypeScript `@ai-sdk/deepseek` package, which has
neither.

## Examples

### Basic Text Generation

```go
package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/digitallysavvy/go-ai/pkg/ai"
    "github.com/digitallysavvy/go-ai/pkg/providers/deepseek"
)

func main() {
    ctx := context.Background()
    provider := deepseek.New(deepseek.Config{
        APIKey: os.Getenv("DEEPSEEK_API_KEY"),
    })

    model, err := provider.LanguageModel("deepseek-chat")
    if err != nil {
        log.Fatal(err)
    }

    result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
        Model:  model,
        Prompt: "Explain gradient descent",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(result.Text)
}
```

### Complex Reasoning

```go
reasoner, err := provider.LanguageModel("deepseek-reasoner")

result, err := ai.GenerateText(ctx, ai.GenerateTextOptions{
    Model:  reasoner,
    Prompt: "A farmer has 100 feet of fence. What's the maximum area he can enclose?",
})

fmt.Println("Reasoning:", result.ReasoningText)
fmt.Println("Answer:", result.Text)
```

## Best Practices

1. **Model Selection**
   - Use deepseek-chat for general tasks
   - Use deepseek-reasoner for math/logic problems
   - Use deepseek-coder for programming

2. **Cost Optimization**
   - Significantly cheaper than GPT-4
   - Great for high-volume applications
   - Excellent price-performance ratio

3. **V4 Reasoning Round-Trips**
   - For `deepseek-v4*` multi-turn chats, include prior assistant `ReasoningContent` so `reasoning_content` is preserved across turns.

## Rate Limits & Pricing

### Rate Limits

| Model | RPM | Tokens/Min |
|-------|-----|------------|
| DeepSeek Chat | 60 | 200K |
| DeepSeek Reasoner | 30 | 100K |

## See Also

- [API Reference: GenerateText](https://goaisdk.com/docs/reference/ai/generate-text.md)
- [DeepSeek Documentation](https://platform.deepseek.com/docs)

## May 2026 parity updates

### DeepSeek v4 reasoning

The DeepSeek provider preserves `reasoning_content` for DeepSeek v4-style multi-turn requests. Reasoning output maps to `types.ReasoningContent` and is forwarded when the result is reused as message history.

```go
p := deepseek.New(deepseek.Config{APIKey: os.Getenv("DEEPSEEK_API_KEY")})
model, err := p.LanguageModel("deepseek-reasoner")
```