Exemples d'Utilisation

Explorez des exemples pratiques d'intégration de l'API Arkangel AI dans vos applications.

Question Médicale Simple

Le cas d'utilisation le plus basique : poser une question et obtenir une réponse.

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

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

// Utilisation
const reponse = await askMedicalQuestion(
  "Quels sont les effets secondaires courants de l'ibuprofène ?"
);
console.log(reponse);

Chat avec Historique

Maintenez une conversation avec un contexte complet.

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;
  }
}

// Utilisation
const chat = new MedicalChat('votre_cle_api');

await chat.sendMessage("Qu'est-ce que l'hypertension ?");
await chat.sendMessage('Quels sont ses symptômes ?');
await chat.sendMessage('Comment peut-on la prévenir ?');

Analyse de Documents

Téléchargez un document médical et posez des questions à son sujet.

async function analyzeDocument(file, question) {
  // 1. Télécharger le fichier
  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 votre_cle_api'
    },
    body: formData
  });

  const uploadData = await uploadResponse.json();

  // 2. Interroger avec le fichier
  const chatResponse = await fetch('https://api.arkangelai.com/v1/chat', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer votre_cle_api',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: question,
      file_ids: [uploadData.file_id]
    })
  });

  return chatResponse.json();
}

// Utilisation
const resultat = await analyzeDocument(
  pdfFile,
  'Résumez les principales conclusions de cette étude'
);

Streaming en Temps Réel

Affichez les réponses au fur et à mesure de leur génération.

async function streamResponse(message, onChunk) {
  const response = await fetch('https://api.arkangelai.com/v1/chat/stream', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer votre_cle_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);
  }
}

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

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

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

Intégration Python

Exemple complet utilisant 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()


# Utilisation
client = ArkangelClient('votre_cle_api')

# Chat simple
reponse = client.chat("Qu'est-ce que le cholestérol ?")
print(reponse['message'])

# Conversation continue
client.chat('Quelles sont les valeurs normales ?')
client.chat('Comment peut-on le réduire ?')

# Voir l'utilisation
utilisation = client.get_usage()
print(f"Requêtes aujourd'hui: {utilisation['usage']['total_requests']}")

Gestion des Erreurs

Implémentez une gestion robuste des erreurs.

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) {
        // Limite atteinte - attendre et réessayer
        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 || "Erreur de l'API");
      }

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

  throw lastError;
}

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

Prochaines Étapes

• Référence HTTP - Documentation complète des points d'accès
• Support - Obtenez de l'aide supplémentaire