Content-Type: application/json
Authorization: Bearer YOUR_API_KEY
Accept: application/json

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer \${DEEPSEEK_API_KEY}" \
  -d '{
        "model": "deepseek-chat",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"}
        ],
        "stream": false
      }'

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "deepseek-chat",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Hello! How can I assist you today?"
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 8,
    "total_tokens": 18
  }
}

POST https://api.deepseek.com/chat/completions

{
  "model": "deepseek-chat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "Hello!"
    }
  ]
}

import json
from openai import OpenAI

client = OpenAI(
    api_key="ваш_api_ключ",
    base_url="https://api.deepseek.com",
)

system_prompt = """
Пользователь предоставит текст. Пожалуйста, распарсите "вопрос" и "ответ" 
и выведите их в JSON формате.

ПРИМЕР ВВОДА: 
Какая самая высокая гора в мире? Эверест.

ПРИМЕР JSON ВЫВОДА:
{
    "question": "Какая самая высокая гора в мире?",
    "answer": "Эверест"
}
"""

user_prompt = "Какая самая длинная река в мире? Нил."

messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": user_prompt}
]

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=messages,
    response_format={'type': 'json_object'}
)

print(json.loads(response.choices[0].message.content))

from openai import OpenAI

client = OpenAI(
    api_key="ваш_api_ключ",
    base_url="https://api.deepseek.com",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Получить погоду в указанном месте",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Город и область, например: Москва"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "Какая погода в Москве?"}
]

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=messages,
    tools=tools
)

# Обработка ответа с вызовом функции
message = response.choices[0].message
if message.tool_calls:
    tool_call = message.tool_calls[0]
    function_name = tool_call.function.name
    arguments = json.loads(tool_call.function.arguments)
    
    print(f"Вызвана функция: {function_name}")
    print(f"Аргументы: {arguments}")

import requests
import json

class DeepSeekClient:
    def __init__(self, api_key, base_url="https://api.deepseek.com"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def chat_completion(self, messages, model="deepseek-chat", **kwargs):
        url = f"{self.base_url}/chat/completions"
        
        payload = {
            "model": model,
            "messages": messages,
            **kwargs
        }
        
        try:
            response = requests.post(
                url,
                headers=self.headers,
                json=payload,
                timeout=60
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API Error: {e}")
            return None

# Использование
client = DeepSeekClient("ваш_api_ключ")
messages = [
    {"role": "system", "content": "Ты полезный ассистент."},
    {"role": "user", "content": "Привет!"}
]

response = client.chat_completion(messages, temperature=0.7)
if response:
    print(response['choices'][0]['message']['content'])

def stream_chat(self, messages, model="deepseek-chat", **kwargs):
    url = f"{self.base_url}/chat/completions"
    
    payload = {
        "model": model,
        "messages": messages,
        "stream": True,
        **kwargs
    }
    
    response = requests.post(
        url,
        headers=self.headers,
        json=payload,
        stream=True,
        timeout=60
    )
    response.raise_for_status()
    
    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith("data: "):
                data = line[6:]
                if data != "[DONE]":
                    try:
                        chunk = json.loads(data)
                        if 'choices' in chunk and chunk['choices']:
                            delta = chunk['choices'][0].get('delta', {})
                            if 'content' in delta:
                                print(delta['content'], end='', flush=True)
                    except json.JSONDecodeError:
                        continue

const axios = require('axios');

class DeepSeekClient {
    constructor(apiKey, baseUrl = 'https://api.deepseek.com') {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl;
        this.client = axios.create({
            baseURL: this.baseUrl,
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            },
            timeout: 60000
        });
    }

    async chatCompletion(messages, options = {}) {
        const {
            model = 'deepseek-chat',
            temperature = 0.7,
            max_tokens = 1000,
            stream = false,
            ...otherOptions
        } = options;

        try {
            const response = await this.client.post('/chat/completions', {
                model,
                messages,
                temperature,
                max_tokens,
                stream,
                ...otherOptions
            });

            return response.data;
        } catch (error) {
            console.error('API Error:', error.response?.data || error.message);
            throw error;
        }
    }
}

// Использование
async function main() {
    const client = new DeepSeekClient('ваш_api_ключ');
    
    const messages = [
        { role: 'system', content: 'Ты полезный ассистент.' },
        { role: 'user', content: 'Привет!' }
    ];

    try {
        const response = await client.chatCompletion(messages, {
            temperature: 0.7,
            max_tokens: 500
        });

        console.log('Ответ:', response.choices[0].message.content);
    } catch (error) {
        console.error('Ошибка:', error);
    }
}

main();

def handle_api_error(error):
    """Обработка ошибок API"""
    
    if isinstance(error, requests.exceptions.HTTPError):
        status_code = error.response.status_code
        
        if status_code == 400:
            return "Некорректный запрос. Проверьте параметры."
        elif status_code == 401:
            return "Неверный API ключ. Проверьте аутентификацию."
        elif status_code == 429:
            return "Превышены лимиты запросов. Попробуйте позже."
        elif status_code >= 500:
            return "Ошибка сервера DeepSeek. Попробуйте позже."
        else:
            return f"HTTP ошибка {status_code}: {error.response.text}"
    
    elif isinstance(error, requests.exceptions.Timeout):
        return "Таймаут запроса. Проверьте соединение."
    
    elif isinstance(error, requests.exceptions.ConnectionError):
        return "Ошибка соединения. Проверьте сеть."
    
    else:
        return f"Неизвестная ошибка: {str(error)}"

import os
from dotenv import load_dotenv

load_dotenv()
API_KEY = os.getenv('DEEPSEEK_API_KEY')

import time
from functools import wraps

def rate_limiter(max_calls, period):
    """Декоратор для ограничения частоты запросов"""
    def decorator(func):
        calls = []
        
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            calls[:] = [call for call in calls if call > now - period]
            
            if len(calls) >= max_calls:
                sleep_time = period - (now - calls[0])
                time.sleep(sleep_time)
            
            calls.append(now)
            return func(*args, **kwargs)
        
        return wrapper
    return decorator

# Использование
@rate_limiter(max_calls=50, period=60)  # 50 запросов в минуту
def make_api_call():
    # ваш код
    pass

from openai import OpenAI

client = OpenAI(
    api_key="ваш_api_ключ",
    base_url="https://api.deepseek.com/beta",
)

response = client.completions.create(
    model="deepseek-chat",
    prompt="def fib(a):",
    suffix="    return fib(a-1) + fib(a-2)",
    max_tokens=128
)

print(response.choices[0].text)

from openai import OpenAI

client = OpenAI(
    api_key="ваш_api_ключ",
    base_url="https://api.deepseek.com/beta",
)

messages = [
    {"role": "user", "content": "Напишите код быстрой сортировки"},
    {"role": "assistant", "content": "```python\n", "prefix": True}
]

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=messages,
    stop=["```"],
)

print(response.choices[0].message.content)