Complétions de chat

YouRouter propose deux façons principales d’interagir avec les modèles de chat :

API compatible OpenAI : la méthode recommandée pour la plupart des cas, avec une interface unifiée pour tous les modèles.
API natives des fournisseurs : pour les cas avancés qui exigent des fonctionnalités propres au fournisseur, absentes de l’API unifiée.

Pour le choix des fournisseurs et des modèles, voir le guide Routage.

API compatible OpenAI

C’est la façon la plus simple et la plus souple d’utiliser YouRouter : les SDK OpenAI habituels, avec des changements de code minimes pour changer de modèle ou de fournisseur.

Utilisation de base

L’exemple suivant envoie une requête de complétion de chat de base. Modifiez le champ model et l’en-tête vendor pour cibler d’autres modèles et fournisseurs.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.yourouter.ai/v1"
)

# Target OpenAI's gpt-4o model
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    extra_headers={"vendor": "openai"}
)

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

Fonctionnalités avancées

Conversation multi-tours

Pour poursuivre une conversation, passez tout l’historique dans le tableau messages.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.yourouter.ai/v1"
)

messages = [
    {"role": "system", "content": "You are a witty assistant that tells jokes."},
    {"role": "user", "content": "Tell me a joke about computers."},
    {"role": "assistant", "content": "Why did the computer keep sneezing? It had a virus!"},
    {"role": "user", "content": "That was a good one. Tell me another."}
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages
)

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

Réponses en flux (streaming)

Pour les applications temps réel (chatbots, etc.), streamez la réponse pendant sa génération en définissant stream=True.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.yourouter.ai/v1"
)

stream = client.chat.completions.create(
    model="claude-3-haiku-20240307",
    messages=[{"role": "user", "content": "Write a short poem about the ocean."}],
    stream=True,
    extra_headers={"vendor": "anthropic"}
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="")

Appel de fonctions / outils (tool use)

Vous pouvez permettre aux modèles d’utiliser des outils ou d’appeler des fonctions vers des systèmes externes. Le flux comporte plusieurs étapes :

Vous envoyez une requête avec la liste des outils disponibles.
Le modèle répond en demandant d’appeler un ou plusieurs de ces outils.
Vous exécutez les outils dans votre code.
Vous renvoyez les résultats au modèle, qui produit alors une réponse finale en langage naturel.

import json
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.yourouter.ai/v1"
)

# Step 1: Define a mock function and the tools for the model
def get_current_weather(location, unit="celsius"):
    """Get the current weather in a given location"""
    if "boston" in location.lower():
        return json.dumps({"location": "Boston", "temperature": "10", "unit": unit})
    else:
        return json.dumps({"location": location, "temperature": "unknown"})

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["location"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather like in Boston, MA?"}]

print("--- Step 1: Sending request to the model with tool definitions ---")
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

response_message = response.choices[0].message
tool_calls = response_message.tool_calls

# Step 2: Check if the model wants to call a tool
if tool_calls:
    print("--- Step 2: Model wants to call a tool. ---")
    print(tool_calls)

    # Step 3: Execute the function and get results
    # Note: the JSON response may not always be valid; be sure to handle errors
    available_functions = {
        "get_current_weather": get_current_weather,
    }
    messages.append(response_message)  # extend conversation with assistant's reply

    # In a real application, you may want to handle multiple tool calls here
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_to_call = available_functions[function_name]
        function_args = json.loads(tool_call.function.arguments)

        print(f"--- Step 3: Executing function '{function_name}' with args {function_args} ---")
        function_response = function_to_call(
            location=function_args.get("location"),
            unit=function_args.get("unit"),
        )
        print(f"--- Got result: {function_response} ---")

        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response,
            }
        )  # extend conversation with function response

    # Step 4: Send the tool results back to the model
    print("--- Step 4: Sending tool results back to the model for final response ---")
    second_response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
    )

    final_response = second_response.choices[0].message.content
    print("--- Final Answer ---")
    print(final_response)

Vision (complétions multimodales)

De nombreux modèles acceptent des entrées multimodales, y compris des images : description, analyse, questions-réponses visuelles, etc. Ce n’est pas limité à un seul fournisseur ; des modèles comme gpt-4o, claude-3-5-sonnet-20240620 et gemini-1.5-pro-latest prennent en charge la vision.

import base64
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.yourouter.ai/v1"
)

# Helper function to encode the image
def encode_image(image_path):
  with open(image_path, "rb") as image_file:
    return base64.b64encode(image_file.read()).decode('utf-8')

# Path to your image
image_path = "image.jpg"
base64_image = encode_image(image_path)

response = client.chat.completions.create(
    model="claude-3-5-sonnet-20240620",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What’s in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                }
            ]
        }
    ],
    max_tokens=300,
    extra_headers={"vendor": "anthropic"}
)

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

Paramètres

Paramètre	Type	Description	Défaut
`model`	string	ID du modèle à utiliser.	Obligatoire
`messages`	array	Liste des messages constituant la conversation jusqu’ici.	Obligatoire
`max_tokens`	integer	Nombre maximal de jetons à générer pour la complétion.	null
`temperature`	number	Température d’échantillonnage entre 0 et 2.	1
`top_p`	number	Alternative à la température : échantillonnage nucleus.	1
`n`	integer	Nombre de choix de complétion à générer pour chaque message d’entrée.	1
`stream`	boolean	Si défini, des deltas de message partiels sont envoyés (comme dans ChatGPT).	false
`stop`	string ou array	Jusqu’à 4 séquences où l’API arrête de générer des jetons.	null
`presence_penalty`	number	Entre -2,0 et 2,0. Les valeurs positives pénalisent les nouveaux jetons s’ils apparaissent déjà dans le texte.	0
`frequency_penalty`	number	Entre -2,0 et 2,0. Les valeurs positives pénalisent selon la fréquence des jetons dans le texte.	0
`logit_bias`	map	Modifie la probabilité d’apparition de jetons donnés dans la complétion.	null
`user`	string	Identifiant unique de l’utilisateur final pour surveillance et détection d’abus.	null
`tool_choice`	string ou objet	Contrôle si et comment le modèle utilise les outils.	`none`
`tools`	array	Liste des outils que le modèle peut appeler.	null

API natives des fournisseurs

Pour les cas avancés qui exigent des paramètres ou fonctionnalités absentes de l’API compatible OpenAI, appelez directement les points de terminaison natifs du fournisseur. Vous devez inclure l’en-tête vendor dans ces requêtes.

YouRouter transmet l’intégralité du corps de requête (et tous les en-têtes sauf Authorization) au fournisseur amont. Voir le guide Transfert des requêtes.

Gemini (Google)

Générer du contenu

Point de terminaison : POST /v1/projects/cognition/locations/us/publishers/google/models/{model}:generateContent

import requests
import json

url = "https://api.yourouter.ai/v1/projects/cognition/locations/us/publishers/google/models/gemini-1.5-pro-latest:generateContent"

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "vendor": "google"
}

data = {
    "contents": [{
        "parts": [{"text": "Write a short story about a time-traveling historian."}]
    }]
}

response = requests.post(url, headers=headers, json=data)

print(json.dumps(response.json(), indent=2))

Paramètres de sécurité

Vous pouvez définir des seuils de contenu avec l’objet safetySettings dans la requête. Liste complète des catégories et seuils : documentation Google AI.

import requests
import json

url = "https://api.yourouter.ai/v1/projects/cognition/locations/us/publishers/google/models/gemini-pro:generateContent"

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "vendor": "google"
}

data = {
    "contents": [{"parts": [{"text": "Tell me a potentially controversial joke."}]}],
    "safetySettings": [
        {
            "category": "HARM_CATEGORY_HATE_SPEECH",
            "threshold": "BLOCK_LOW_AND_ABOVE"
        },
        {
            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
        }
    ]
}

response = requests.post(url, headers=headers, json=data)

print(json.dumps(response.json(), indent=2))

Claude (Anthropic)

API Messages

Point de terminaison : POST /v1/messages Envoyez un message à Claude via l’API Messages.

import requests
import json

url = "https://api.yourouter.ai/v1/messages"

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "anthropic-version": "2023-06-01",
    "vendor": "anthropic"
}

data = {
    "model": "claude-3-5-sonnet-20240620",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Explain the concept of neural networks to a 5-year-old."}
    ]
}

response = requests.post(url, headers=headers, json=data)

print(json.dumps(response.json(), indent=2))

Utilisation d’outils avec Claude

Vous pouvez fournir à Claude un ensemble d’outils ; le modèle décide quand les utiliser pour répondre. Le flux implique plusieurs tours : votre code exécute l’outil et renvoie le résultat à Claude. Exemple complet du cycle de vie des outils :

import requests
import json

# --- Step 1: Define a tool and send the initial request ---

# This is a mock function. In a real application, this would
# call a weather API.
def get_weather(location):
    if "san francisco" in location.lower():
        return json.dumps({"location": "San Francisco", "temperature": "15°C", "forecast": "Cloudy"})
    else:
        return json.dumps({"location": location, "temperature": "unknown"})

# Define the tool for the model
tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather in a given location.",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                }
            },
            "required": ["location"]
        }
    }
]

# Initial user message
messages = [{"role": "user", "content": "What is the weather like in San Francisco?"}]

initial_data = {
    "model": "claude-3-opus-20240229",
    "max_tokens": 1024,
    "tools": tools,
    "messages": messages
}

print("--- Step 1: Sending request to Claude with tool definition ---")
response = requests.post(
    "https://api.yourouter.ai/v1/messages",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
        "anthropic-version": "2023-06-01",
        "vendor": "anthropic"
    },
    json=initial_data
)

response_data = response.json()
print(json.dumps(response_data, indent=2))

# --- Step 2: Check if the model wants to use a tool ---

if response_data.get("stop_reason") == "tool_use":
    tool_use_block = next(
        (block for block in response_data["content"] if block.get("type") == "tool_use"), None
    )

    if tool_use_block:
        tool_name = tool_use_block["name"]
        tool_input = tool_use_block["input"]
        tool_use_id = tool_use_block["id"]

        print(f"--- Step 2: Claude wants to use the '{tool_name}' tool with input: {tool_input} ---")

        # --- Step 3: Execute the tool and get the result ---

        if tool_name == "get_weather":
            tool_result = get_weather(tool_input.get("location", ""))
            print(f"--- Step 3: Executed local function '{tool_name}', got result: {tool_result} ---")

            # --- Step 4: Send the result back to Claude ---

            # Append the assistant's response and the tool result to the message history
            messages.append({"role": "assistant", "content": response_data["content"]})
            messages.append({
                "role": "user",
                "content": [
                    {
                        "type": "tool_result",
                        "tool_use_id": tool_use_id,
                        "content": tool_result,
                    }
                ],
            })

            print("--- Step 4: Sending tool result back to Claude ---")
            final_data = {
                "model": "claude-3-opus-20240229",
                "max_tokens": 1024,
                "tools": tools,
                "messages": messages
            }

            final_response = requests.post(
                "https://api.yourouter.ai/v1/messages",
                headers={
                    "Authorization": "Bearer YOUR_API_KEY",
                    "Content-Type": "application/json",
                    "anthropic-version": "2023-06-01",
                    "vendor": "anthropic"
                },
                json=final_data
            ).json()

            print("--- Step 5: Final response from Claude ---")
            print(json.dumps(final_response, indent=2))

            # Extract and print the final text response
            final_text = next(
                (block["text"] for block in final_response["content"] if block.get("type") == "text"),
                "No final text response found."
            )
            print("\nFinal Answer:\n", final_text)

Bonnes pratiques

Routage : en production, utilisez le mode auto pour la haute disponibilité. Pour une version de modèle ou une fonctionnalité précise, utilisez le routage manuel. Détails dans le guide Routage.
Gestion des erreurs : pannes réseau et indisponibilités fournisseur sont possibles. Prévoyez des nouvelles tentatives avec backoff exponentiel, surtout pour les tâches longues.
Streaming et UX : pour toute interface utilisateur, le streaming offre une expérience temps réel plus fluide.
Prompts système : un prompt système soigné guide le comportement, le ton et la personnalité du modèle. Testez et affinez-le.
Jetons : respectez les limites de contexte et de sortie. Surveillez le champ usage dans la réponse pour suivre les coûts et éviter une troncature inattendue.

Premiers pas

API modèles

Routage et fiabilité

Référence API

Fonctionnalités

Juridique

API compatible OpenAI

Utilisation de base

Fonctionnalités avancées

Conversation multi-tours

Réponses en flux (streaming)

Appel de fonctions / outils (tool use)

Vision (complétions multimodales)

Paramètres

API natives des fournisseurs

Gemini (Google)

Générer du contenu

Paramètres de sécurité

Claude (Anthropic)

API Messages

Utilisation d’outils avec Claude

Bonnes pratiques

Premiers pas

API modèles

Routage et fiabilité

Référence API

Fonctionnalités

Juridique

​API compatible OpenAI

​Utilisation de base

​Fonctionnalités avancées

​Conversation multi-tours

​Réponses en flux (streaming)

​Appel de fonctions / outils (tool use)

​Vision (complétions multimodales)

​Paramètres

​API natives des fournisseurs

​Gemini (Google)

​Générer du contenu

​Paramètres de sécurité

​Claude (Anthropic)

​API Messages

​Utilisation d’outils avec Claude

​Bonnes pratiques

API compatible OpenAI

Utilisation de base

Fonctionnalités avancées

Conversation multi-tours

Réponses en flux (streaming)

Appel de fonctions / outils (tool use)

Vision (complétions multimodales)

Paramètres

API natives des fournisseurs

Gemini (Google)

Générer du contenu

Paramètres de sécurité

Claude (Anthropic)

API Messages

Utilisation d’outils avec Claude

Bonnes pratiques