DeepSeek Provider

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

Setup

Installation

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

Configuration

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
2. Create API key
3. Set environment variable:

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:

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:

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:

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:

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

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

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
• DeepSeek Documentation

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.

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