Integra las APIs de DeepSeek en tus aplicaciones en solo 5 minutos

En la era de las aplicaciones impulsadas por IA, integrar modelos de lenguaje avanzados en tu software puede desbloquear capacidades sin precedentes, desde chatbots inteligentes hasta herramientas de análisis de datos. Las APIs de DeepSeek ofrecen funcionalidades de IA de vanguardia, pero el verdadero desafío radica en integrarlas sin problemas en tu aplicación sin atascarte con la depuración o el código repetitivo.

Esta guía te lleva a través de todo el proceso de integración de las APIs de DeepSeek en tu aplicación, aprovechando una plataforma de API intuitiva: Apidog para probar, depurar y generar fragmentos de código listos para usar en minutos. Ya sea que estés construyendo un backend en Python o un frontend en JavaScript, al final de este artículo, tendrás una integración de API completamente funcional con un mínimo esfuerzo.

Requisitos previos

Una cuenta de DeepSeek (regístrate aquí).
Conocimientos básicos de las APIs REST y programación (Python/JavaScript se utilizan aquí).
Una herramienta como Apidog para probar las APIs.

Paso 1: Obtener la clave de la API de DeepSeek

Cada solicitud de API requiere autenticación. Aquí te mostramos cómo obtener tu clave:

Inicia sesión en tu cuenta de DeepSeek.
Navega a API Keys en la configuración de tu cuenta.
Haz clic en Create new APl key y cópiala.

⚠️ Importante: Trata esta clave como una contraseña. Nunca la expongas en el código del lado del cliente o en repositorios públicos.

Paso 2: Probar la API de DeepSeek

La documentación de la API de DeepSeek creada por Apidog proporciona un entorno de pruebas interactivo para probar los endpoints directamente en la documentación sin escribir una sola línea de código. Aquí te mostramos cómo:

1. Abre la documentación: Navega al endpoint Create Chat Completion.

2. Autentícate:

Haz clic en Try it out o Run in Apidog.
En el panel de solicitud emergente, navega a la sección Headers o Auth y agrega tu clave de API:

Authorization: Bearer YOUR_API_KEY

3. Elabora tu solicitud:

En el cuerpo de la solicitud, especifica el modelo (por ejemplo, deepseek-chat) y agrega un mensaje:

{
  "model": "deepseek-chat",
  "messages": [
    {"role": "user", "content": "Explain quantum computing in 3 sentences."}
  ]
}

4. Envía la solicitud: Haz clic en Send y visualiza la respuesta en tiempo real.

Por qué esto importa: Probar las APIs manualmente te ayuda a validar las estructuras de carga útil y el manejo de errores antes de escribir el código de integración.

Paso 3: Generar fragmentos de código para tu stack

Apidog te permite generar códigos empresariales listos para usar para diferentes lenguajes y frameworks basados en la documentación de la API que se pueden utilizar directamente en tu stack. Aquí te mostramos cómo:

1. Abre el proyecto DeekSeek en la aplicación Apidog:

Para abrir el proyecto de la API de DeepSeek en la aplicación web de Apidog, simplemente haz clic en "Run in Apidog" en la parte superior derecha de la documentación.

Click on "Run in Apidog" to run the project on Apidog app

CONSEJO PROFESIONAL: Para abrir el proyecto en la aplicación de escritorio de Apidog, haz clic en "Open on desktop" en la parte superior derecha después de eso.

2. Elige tu lenguaje:

En la página de documentación de la API de DeepSeek, haz clic en el botón </> Generate Code.

generating code directly from API documentation created by Apidog

Selecciona tu lenguaje (por ejemplo, Python, JavaScript, Go y más).

choose the language to generate the codes

3. Copia y pega el código:

Para Python (usando requests):

import requests
import json

url = "https://api.deepseek.com/chat/completions"

payload = json.dumps({
   "messages": [
      {
         "content": "You are a helpful assistant",
         "role": "system"
      },
      {
         "content": "Hi",
         "role": "user"
      }
   ],
   "model": "deepseek-chat",
   "frequency_penalty": 0,
   "max_tokens": 2048,
   "presence_penalty": 0,
   "response_format": {
      "type": "text"
   },
   "stop": None,
   "stream": False,
   "stream_options": None,
   "temperature": 1,
   "top_p": 1,
   "tools": None,
   "tool_choice": "none",
   "logprobs": False,
   "top_logprobs": None
})
headers = {
   'Authorization': 'Bearer {{API_KEY}}',
   'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

Para JavaScript (usando fetch):

var myHeaders = new Headers();
myHeaders.append("Authorization", "Bearer {{API_KEY}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
   "messages": [
      {
         "content": "You are a helpful assistant",
         "role": "system"
      },
      {
         "content": "Hi",
         "role": "user"
      }
   ],
   "model": "deepseek-chat",
   "frequency_penalty": 0,
   "max_tokens": 2048,
   "presence_penalty": 0,
   "response_format": {
      "type": "text"
   },
   "stop": null,
   "stream": false,
   "stream_options": null,
   "temperature": 1,
   "top_p": 1,
   "tools": null,
   "tool_choice": "none",
   "logprobs": false,
   "top_logprobs": null
});

var requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body: raw,
   redirect: 'follow'
};

fetch("https://api.deepseek.com/chat/completions", requestOptions)
   .then(response => response.text())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

4. Personaliza el código: Reemplaza YOUR_API_KEY y modifica el contenido del mensaje.

Paso 4: Integrar en tu aplicación

Construyamos una sencilla aplicación CLI de Python que utiliza la API de DeepSeek para responder a las preguntas de los usuarios.

Configuración del proyecto

1. Crea un directorio e instala las dependencias:

mkdir deepseek-cli && cd deepseek-cli  
pip install requests python-dotenv

2. Almacena tu clave de API de forma segura usando .env:

echo "DEEPSEEK_API_KEY=your_api_key_here" > .env

Implementación del código

import argparse
import asyncio
import json
import os
import sys
from typing import AsyncGenerator, Generator

import httpx
import requests


async def async_deepseek(
    api_key: str,
    model: str,
    messages: list,
    temperature: float
) -> AsyncGenerator[str, None]:
    """
    Asynchronous generator for streaming DeepSeek responses
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}",
    }
    data = {
        "model": model,
        "messages": messages,
        "temperature": temperature,
        "stream": True,
    }

    async with httpx.AsyncClient() as client:
        async with client.stream(
            "POST",
            "https://api.deepseek.com/v1/chat/completions",
            headers=headers,
            json=data,
        ) as response:
            response.raise_for_status()
            async for line in response.aiter_lines():
                if line.startswith("data: "):
                    try:
                        json_data = json.loads(line[6:])
                        if chunk := json_data["choices"][0]["delta"].get("content", ""):
                            yield chunk
                    except json.JSONDecodeError:
                        pass


def sync_deepseek(
    api_key: str,
    model: str,
    messages: list,
    temperature: float
) -> Generator[str, None, None]:
    """
    Synchronous generator for streaming DeepSeek responses
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}",
    }
    data = {
        "model": model,
        "messages": messages,
        "temperature": temperature,
        "stream": True,
    }

    with requests.post(
        "https://api.deepseek.com/v1/chat/completions",
        headers=headers,
        json=data,
        stream=True,
    ) as response:
        response.raise_for_status()
        for line in response.iter_lines():
            if line:
                decoded_line = line.decode("utf-8")
                if decoded_line.startswith("data: "):
                    try:
                        json_data = json.loads(decoded_line[6:])
                        if chunk := json_data["choices"][0]["delta"].get("content", ""):
                            yield chunk
                    except json.JSONDecodeError:
                        pass


def main():
    parser = argparse.ArgumentParser(
        description="DeepSeek CLI Client - Chat with DeepSeek models"
    )
    parser.add_argument(
        "prompt",
        type=str,
        help="Your message to send to DeepSeek"
    )
    parser.add_argument(
        "--model",
        type=str,
        default="deepseek-chat",
        help="Model to use (default: deepseek-chat)"
    )
    parser.add_argument(
        "--temperature",
        type=float,
        default=0.7,
        help="Temperature parameter (default: 0.7)"
    )
    parser.add_argument(
        "--async-mode",
        action="store_true",
        help="Use asynchronous mode (requires Python 3.7+)"
    )
    args = parser.parse_args()

    api_key = os.getenv("DEEPSEEK_API_KEY")
    if not api_key:
        print("Error: Set your API key in DEEPSEEK_API_KEY environment variable")
        sys.exit(1)

    messages = [{"role": "user", "content": args.prompt}]

    try:
        if args.async_mode:
            async def run_async():
                try:
                    async for chunk in async_deepseek(
                        api_key=api_key,
                        model=args.model,
                        messages=messages,
                        temperature=args.temperature
                    ):
                        print(chunk, end="", flush=True)
                    print()
                except httpx.HTTPStatusError as e:
                    print(f"\nHTTP error occurred: {e.response.status_code} {e.response.reason_phrase}")
                except Exception as e:
                    print(f"\nAn error occurred: {str(e)}")

            asyncio.run(run_async())
        else:
            try:
                for chunk in sync_deepseek(
                    api_key=api_key,
                    model=args.model,
                    messages=messages,
                    temperature=args.temperature
                ):
                    print(chunk, end="", flush=True)
                print()
            except requests.exceptions.HTTPError as e:
                print(f"\nHTTP error occurred: {e.response.status_code} {e.response.reason_phrase}")
            except Exception as e:
                print(f"\nAn error occurred: {str(e)}")

    except KeyboardInterrupt:
        print("\n\nOperation interrupted by user")
        sys.exit(0)


if __name__ == "__main__":
    main()

Ejecuta la aplicación

Escribe una pregunta (por ejemplo, "¿Cuál es la capital de Francia?") y observa la respuesta.

Paso 5: Manejar errores y casos extremos

Las APIs pueden fallar debido a límites de velocidad, claves no válidas o problemas de red. Implementa un manejo de errores robusto:

1. Verifica los códigos de estado HTTP:

401 Unauthorized: Clave de API no válida.
429 Too Many Requests: Se excedió el límite de velocidad.
500 Internal Server Error: Problema del lado del servidor.

2. Mecanismos de reintento:

from time import sleep

def get_deepseek_response(prompt, retries=3):
    # ... existing code ...
    except requests.exceptions.RequestException as e:
        if retries > 0:
            sleep(2)
            return get_deepseek_response(prompt, retries - 1)
        else:
            return f"Error: {str(e)}"

3. Valida las entradas:
Asegúrate de que los prompts estén dentro de los límites de tokens y estén formateados correctamente.

Paso 6: Optimizar para producción

Almacena en caché las respuestas: Utiliza Redis o Memcached para almacenar las consultas frecuentes.
Supervisa el uso: Realiza un seguimiento de las llamadas a la API para evitar exceder las cuotas.
Procesamiento asíncrono: Para aplicaciones de alto rendimiento, utiliza bibliotecas asíncronas como aiohttp (Python) o axios (JavaScript).

Conclusión

Integrar las APIs de DeepSeek en tu aplicación no tiene por qué ser una pérdida de tiempo. Al utilizar la documentación interactiva para probar los endpoints, generar código y depurar sobre la marcha, puedes enviar funciones impulsadas por IA en horas, no en días.

El ejemplo anterior es solo la punta del iceberg. Con los modelos de DeepSeek, puedes construir cualquier cosa, desde generadores de contenido automatizados hasta tutores de IA. Ahora que tienes el plano, adelante y transforma tu aplicación en una potencia de IA.