Ejemplos de Uso

Explora ejemplos prácticos de cómo integrar la API de Arkangel AI en tus aplicaciones.

Consulta Médica Simple

El caso de uso más básico: hacer una pregunta y obtener una respuesta.

async function askMedicalQuestion(question) {
  const response = await fetch('https://api.arkangelai.com/v1/chat', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer tu_clave_api',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: question,
      language: 'es'
    })
  });

  const data = await response.json();
  return data.message;
}

// Uso
const respuesta = await askMedicalQuestion(
  '¿Cuáles son los efectos secundarios comunes del ibuprofeno?'
);
console.log(respuesta);

Chat con Historial

Mantén una conversación con contexto completo.

class MedicalChat {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.conversationId = null;
  }

  async sendMessage(message) {
    const body = { message };

    if (this.conversationId) {
      body.conversation_id = this.conversationId;
    }

    const response = await fetch('https://api.arkangelai.com/v1/chat', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(body)
    });

    const data = await response.json();
    this.conversationId = data.conversation_id;

    return data.message;
  }

  reset() {
    this.conversationId = null;
  }
}

// Uso
const chat = new MedicalChat('tu_clave_api');

await chat.sendMessage('¿Qué es la hipertensión?');
await chat.sendMessage('¿Cuáles son sus síntomas?');
await chat.sendMessage('¿Cómo se puede prevenir?');

Análisis de Documentos

Sube un documento médico y haz preguntas sobre él.

async function analyzeDocument(file, question) {
  // 1. Subir el archivo
  const formData = new FormData();
  formData.append('file', file);
  formData.append('purpose', 'analysis');

  const uploadResponse = await fetch('https://api.arkangelai.com/v1/files', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer tu_clave_api'
    },
    body: formData
  });

  const uploadData = await uploadResponse.json();

  // 2. Hacer la consulta con el archivo
  const chatResponse = await fetch('https://api.arkangelai.com/v1/chat', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer tu_clave_api',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: question,
      file_ids: [uploadData.file_id]
    })
  });

  return chatResponse.json();
}

// Uso
const resultado = await analyzeDocument(
  pdfFile,
  'Resume los hallazgos principales de este estudio'
);

Streaming en Tiempo Real

Muestra las respuestas mientras se generan.

async function streamResponse(message, onChunk) {
  const response = await fetch('https://api.arkangelai.com/v1/chat/stream', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer tu_clave_api',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ message })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    onChunk(chunk);
  }
}

// Uso con React
function ChatComponent() {
  const [response, setResponse] = useState('');

  const handleSubmit = async (question) => {
    setResponse('');
    await streamResponse(question, (chunk) => {
      setResponse(prev => prev + chunk);
    });
  };

  return <div>{response}</div>;
}

Integración con Python

Ejemplo completo usando Python.

import requests
from typing import Optional

class ArkangelClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://api.arkangelai.com/v1'
        self.conversation_id: Optional[str] = None

    def _headers(self):
        return {
            'Authorization': f'Bearer {self.api_key}',
            'Content-Type': 'application/json'
        }

    def chat(self, message: str, new_conversation: bool = False) -> dict:
        if new_conversation:
            self.conversation_id = None

        payload = {'message': message}
        if self.conversation_id:
            payload['conversation_id'] = self.conversation_id

        response = requests.post(
            f'{self.base_url}/chat',
            headers=self._headers(),
            json=payload
        )
        response.raise_for_status()

        data = response.json()
        self.conversation_id = data.get('conversation_id')
        return data

    def upload_file(self, file_path: str) -> str:
        with open(file_path, 'rb') as f:
            response = requests.post(
                f'{self.base_url}/files',
                headers={'Authorization': f'Bearer {self.api_key}'},
                files={'file': f},
                data={'purpose': 'analysis'}
            )
        response.raise_for_status()
        return response.json()['file_id']

    def get_usage(self) -> dict:
        response = requests.get(
            f'{self.base_url}/usage',
            headers=self._headers()
        )
        response.raise_for_status()
        return response.json()


# Uso
client = ArkangelClient('tu_clave_api')

# Chat simple
respuesta = client.chat('¿Qué es el colesterol?')
print(respuesta['message'])

# Conversación continua
client.chat('¿Cuáles son los valores normales?')
client.chat('¿Cómo se puede reducir?')

# Ver uso
uso = client.get_usage()
print(f"Solicitudes hoy: {uso['usage']['total_requests']}")

Manejo de Errores

Implementa un manejo robusto de errores.

async function safeApiCall(endpoint, options) {
  const maxRetries = 3;
  let lastError;

  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(endpoint, options);

      if (response.status === 429) {
        // Rate limit - esperar y reintentar
        const retryAfter = response.headers.get('Retry-After') || 60;
        await sleep(retryAfter * 1000);
        continue;
      }

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || 'Error en la API');
      }

      return response.json();
    } catch (error) {
      lastError = error;
      if (i < maxRetries - 1) {
        await sleep(1000 * (i + 1)); // Backoff exponencial
      }
    }
  }

  throw lastError;
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

Próximos Pasos

• Referencia HTTP - Documentación completa de endpoints
• Soporte - Obtén ayuda adicional