> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lighton.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Compatibilité avec le SDK OpenAI

> Utilisez le SDK Python d'OpenAI avec notre API

Notre API est compatible avec le SDK Python d'OpenAI pour certains endpoints spécifiques, vous permettant d'intégrer notre service avec un minimum de modifications de code pour vos tests.

## Installation

Installez le SDK Python d'OpenAI :

```bash theme={null}
pip install openai
```

## Configuration

Configurez le client pour pointer vers notre API :

```python theme={null}
from openai import OpenAI
client = OpenAI(
    api_key="votre-clé-api-paradigm",
    base_url="https://paradigm.lighton.ai/api/v2"
)
```

## Endpoints compatibles

<AccordionGroup>
  <Accordion title="Chat Completions" icon="sparkles">
    ### Chat Completions

    Créez des completions de chat en utilisant la même interface que l'API d'OpenAI.

    ```python theme={null}
    response = client.chat.completions.create(
        model="nom-de-votre-modèle",
        messages=[
            {"role": "system", "content": "Vous êtes un assistant utile."},
            {"role": "user", "content": "Bonjour !"}
        ],
        temperature=0.7,
        max_tokens=150
    )

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

    ## Réponse en streaming

    Diffusez les réponses en temps réel :

    ```python theme={null}
    stream = client.chat.completions.create(
        model="nom-de-votre-modèle",
        messages=[{"role": "user", "content": "Raconte-moi une histoire"}],
        stream=True
    )

    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="")
    ```
  </Accordion>

  <Accordion title="Completions" icon="message">
    ### Completions

    Générez des completions de texte en utilisant l'endpoint historique de completions.

    ```python theme={null}
    response = client.completions.create(
        model="nom-de-votre-modèle",
        prompt="Il était une fois",
        max_tokens=100,
        temperature=0.7
    )

    print(response.choices[0].text)
    ```

    ## Réponse en streaming

    ```python theme={null}
    stream = client.completions.create(
        model="nom-de-votre-modèle",
        prompt="Écris un poème sur",
        stream=True
    )

    for chunk in stream:
        if chunk.choices[0].text:
            print(chunk.choices[0].text, end="")
    ```
  </Accordion>

  <Accordion title="Embeddings" icon="sparkles">
    ### Embeddings

    Générez des embeddings pour du texte :

    ```python theme={null}
    response = client.embeddings.create(
        model="votre-modèle-embedding",
        input="Texte à vectoriser"
    )

    embedding = response.data[0].embedding
    print(embedding)
    ```
  </Accordion>

  <Accordion title="Modèles" icon="list">
    ### Liste des modèles

    Récupérez la liste des modèles disponibles pour l'utilisateur.

    ```python theme={null}
    models = client.models.list()

    for model in models.data:
        print(f"{model.name}: {model.technical_name=} / {model.model_type}")
    ```
  </Accordion>

  <Accordion title="Fichiers" icon="file">
    ### Téléverser des fichiers

    Téléversez des fichiers pour les utiliser avec des assistants ou d'autres endpoints.

    ```python theme={null}
    # Téléverser un fichier
    with open("document.pdf", "rb") as file:
        response = client.files.create(
            file=file,
            purpose="assistants"
        )

    file_id = response.id
    print(f"Fichier téléversé : {file_id}")
    ```

    **Paramètres supportés :**

    * `file` (requis) - Objet fichier à téléverser

    ### Lister les fichiers

    Récupérez la liste de tous les fichiers téléversés.

    ```python theme={null}
    # Lister tous les fichiers
    files = client.files.list()

    for file in files.data:
        print(f"{file.id}: {file.filename} ({file.bytes} octets)")
    ```

    ### Récupérer un fichier

    Obtenez des informations sur un fichier spécifique.

    ```python theme={null}
    # Obtenir les détails du fichier
    file = client.files.retrieve(file_id="file-abc123")

    print(f"Nom du fichier : {file.filename}")
    print(f"Taille : {file.bytes} octets")
    print(f"Créé le : {file.created_at}")
    ```

    ### Supprimer un fichier

    Supprimez un fichier de votre compte.

    ```python theme={null}
    # Supprimer un fichier
    response = client.files.delete("file-abc123")

    if response.deleted:
        print("Fichier supprimé avec succès")
    ```
  </Accordion>
</AccordionGroup>

## Différences par rapport à OpenAI

Bien que notre API maintienne la compatibilité avec le SDK OpenAI, notez les différences suivantes :

<Note>
  Différences importantes :

  * Les noms de modèles sont spécifiques à notre plateforme
  * Certains paramètres avancés peuvent ne pas être supportés
  * Les limites de débit diffèrent de celles d'OpenAI
</Note>

## Gestion des erreurs

Gérez les erreurs en utilisant des blocs try-except standards :

```python theme={null}
from openai import OpenAIError
try:
    response = client.chat.completions.create(
        model="nom-de-votre-modèle",
        messages=[{"role": "user", "content": "Bonjour"}]
    )
except OpenAIError as e:
    print(f"Erreur : {e}")
```

## Guide de migration

Pour migrer d'OpenAI vers notre API :

1. Mettez à jour le paramètre `base_url` dans la configuration de votre client
2. Remplacez les noms de modèles OpenAI par nos identifiants de modèles
3. Mettez à jour votre clé API pour utiliser la clé de notre plateforme
4. Testez votre implémentation avec nos endpoints

```python theme={null}
# Avant (OpenAI)
client = OpenAI(api_key="sk-...")
# Après (LightOn API)
client = OpenAI(
    api_key="votre-clé-api-paradigm",
    base_url="https://paradigm.lighton.ai/api/v2"
)
```