Comment utiliser la bibliothèque Python GPT4Free

```html

Introduction

GPT4Free est une bibliothèque Python open-source qui fournit un accès à une collection de modèles de langage puissants via divers fournisseurs. Elle sert de package API de preuve de concept qui démontre les requêtes d'IA multi-fournisseurs avec des fonctionnalités telles que les délais d'attente, l'équilibrage de charge et le contrôle de flux. Cette bibliothèque permet aux développeurs d'utiliser différents modèles de langage pour la génération de texte, y compris les variantes GPT-3.5 et GPT-4, sans avoir besoin de clés API officielles dans de nombreux cas.

Ce tutoriel vous guidera à travers l'installation, la configuration et l'utilisation de la bibliothèque gpt4free, vous montrant comment exploiter ses capacités pour diverses tâches de génération de texte alimentées par l'IA.

Considérations légales

💡

AVERTISSEMENT : Avant de poursuivre ce tutoriel, il est important de comprendre les implications légales de l'utilisation de la bibliothèque gpt4free.

En utilisant ce référentiel ou tout code qui y est lié, vous acceptez l'avis juridique fourni par les développeurs. L'auteur original n'est pas responsable de l'utilisation de ce référentiel et ne l'approuve pas. L'auteur n'est pas non plus responsable des copies, forks, re-téléchargements effectués par d'autres utilisateurs, ou de toute autre chose liée à GPT4Free.

GPT4Free sert principalement de preuve de concept démontrant le développement d'un package API avec des requêtes multi-fournisseurs. L'utilisation de cette bibliothèque pour contourner les API officielles peut violer les conditions d'utilisation de divers fournisseurs d'IA. Avant de déployer une solution basée sur cette bibliothèque dans un environnement de production, assurez-vous d'avoir l'autorisation appropriée et de respecter les conditions d'utilisation de chaque fournisseur que vous avez l'intention d'utiliser.

Avant de plonger dans les détails de l'implémentation, il convient de mentionner que vous pouvez utiliser Apidog comme une excellente alternative à Postman pour les tests API avec gpt4free. Apidog est une plateforme de développement API complète qui offre des fonctionnalités telles que la conception d'API, le débogage, les tests automatisés et la documentation.

Lorsque vous travaillez avec l'API d'interférence gpt4free, Apidog peut vous aider à :

Envoyer des requêtes aux points de terminaison de l'API
Tester différentes configurations de paramètres
Visualiser les données de réponse
Créer et enregistrer des collections de requêtes API pour une utilisation future

button

Comment installer GPT4Free

Prérequis

Python 3.10 ou supérieur (recommandé)
Google Chrome (requis pour les fournisseurs avec webdriver)

Méthodes pour installer GPT4Free

Méthode 1 : Utilisation de PyPI

Pour une installation complète avec toutes les fonctionnalités :

pip install -U g4f[all]

Pour les installations partielles :

# For OpenAI Chat provider
pip install -U g4f[openai]

# For interference API
pip install -U g4f[api]

# For web interface
pip install -U g4f[gui]

# For image generation
pip install -U g4f[image]

# For providers with webdriver
pip install -U g4f[webdriver]

# For proxy support
pip install -U aiohttp_socks

Méthode 2 : Depuis le référentiel GitHub

# Clone the repository
git clone https://github.com/xtekky/gpt4free.git

# Navigate to the project directory
cd gpt4free

# Create a virtual environment (recommended)
python3 -m venv venv

# Activate the virtual environment
# On Windows:
.\venv\Scripts\activate
# On macOS and Linux:
source venv/bin/activate

# Install minimum requirements
pip install -r requirements-min.txt

# Or install all requirements
pip install -r requirements.txt

Méthode 3 : Utilisation de Docker

# Pull the Docker image
docker pull hlohaus789/g4f

# Run the container
docker run -p 8080:8080 -p 1337:1337 -p 7900:7900 --shm-size="2g" hlohaus789/g4f:latest

Pour la version slim (compatible avec x64 et arm64) :

# Create necessary directories
mkdir -p ${PWD}/har_and_cookies ${PWD}/generated_images
chown -R 1000:1000 ${PWD}/har_and_cookies ${PWD}/generated_images

# Run the slim Docker image
docker run \
  -p 1337:1337 \
  -v ${PWD}/har_and_cookies:/app/har_and_cookies \
  -v ${PWD}/generated_images:/app/generated_images \
  hlohaus789/g4f:latest-slim \
  /bin/sh -c 'rm -rf /app/g4f && pip install -U g4f[slim] && python -m g4f --debug'

Comment utiliser GPT4Free avec les bases de Python

Génération de texte avec ChatCompletion

Exemple simple

import g4f

# Enable debug logging (optional)
g4f.debug.logging = True

# Disable automatic version checking (optional)
g4f.debug.version_check = False

# Normal (non-streaming) response
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello, how are you today?"}]
)
print(response)

Réponse en streaming

import g4f

# Stream the response
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Write a short story about a robot."}],
    stream=True
)

for message in response:
    print(message, end='', flush=True)

Utilisation d'un fournisseur spécifique

import g4f

# List all available working providers
providers = [provider.__name__ for provider in g4f.Provider.__providers__ if provider.working]
print("Available providers:", providers)

# Use a specific provider
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    provider=g4f.Provider.Aichat,
    messages=[{"role": "user", "content": "Explain quantum computing in simple terms."}]
)
print(response)

Utilisation de l'API client

Une approche plus moderne utilisant l'API client :

from g4f.client import Client

# Create a client instance
client = Client()

# Generate text using chat completions
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello"}],
    web_search=False
)
print(response.choices[0].message.content)

Génération d'images

from g4f.client import Client

# Create a client instance
client = Client()

# Generate an image
response = client.images.generate(
    model="flux",
    prompt="a white siamese cat",
    response_format="url"
)
print(f"Generated image URL: {response.data[0].url}")

Authentification du fournisseur

Certains fournisseurs nécessitent des cookies ou des jetons d'accès pour l'authentification :

from g4f import set_cookies

# Set cookies for Bing
set_cookies(".bing", {"_U": "cookie value"})

# Set access token for OpenAI Chat
set_cookies("chat.openai.com", {"access_token": "token value"})

Utilisation de l'automatisation du navigateur

Pour les fournisseurs nécessitant une interaction avec le navigateur :

import g4f
from undetected_chromedriver import Chrome, ChromeOptions

# Configure Chrome options
options = ChromeOptions()
options.add_argument("--incognito")

# Initialize Chrome WebDriver
webdriver = Chrome(options=options, headless=True)

try:
    # Use the browser for multiple requests
    for idx in range(5):
        response = g4f.ChatCompletion.create(
            model=g4f.models.default,
            provider=g4f.Provider.MyShell,
            messages=[{"role": "user", "content": f"Give me idea #{idx+1} for a mobile app."}],
            webdriver=webdriver
        )
        print(f"Idea {idx+1}:", response)
finally:
    # Always close the webdriver when done
    webdriver.quit()

Prise en charge asynchrone

Pour des performances améliorées avec plusieurs requêtes :

import g4f
import asyncio

# Define providers to use
providers = [
    g4f.Provider.Aichat,
    g4f.Provider.ChatBase,
    g4f.Provider.Bing,
    g4f.Provider.GptGo
]

async def run_provider(provider):
    try:
        response = await g4f.ChatCompletion.create_async(
            model=g4f.models.default,
            messages=[{"role": "user", "content": "What's your name?"}],
            provider=provider,
        )
        print(f"{provider.__name__}:", response)
    except Exception as e:
        print(f"{provider.__name__}:", e)

async def run_all():
    calls = [run_provider(provider) for provider in providers]
    await asyncio.gather(*calls)

# Run all providers asynchronously
asyncio.run(run_all())

Prise en charge du proxy et du délai d'attente

Pour gérer les contraintes réseau :

import g4f

# Use with specific proxy and extended timeout
response = g4f.ChatCompletion.create(
    model=g4f.models.default,
    messages=[{"role": "user", "content": "How can I improve my Python code?"}],
    proxy="http://host:port",  # or socks5://user:pass@host:port
    timeout=120  # in seconds
)
print("Result:", response)

Vous pouvez également définir un proxy global via une variable d'environnement :

export G4F_PROXY="http://host:port"

Exécution de l'interface Web avec GPT4Free

GPT4Free inclut une interface Web pour une interaction plus facile :

from g4f.gui import run_gui
run_gui()

Alternativement, utilisez la ligne de commande :

# Start the Flask server
python -m g4f.cli gui --port 8080 --debug

# Or start the FastAPI server
python -m g4f --port 8080 --debug

L'interface Web sera disponible à l'adresse http://localhost:8080/chat/

Utilisation de l'API d'interférence avec GPT4Free

GPT4Free fournit une API compatible avec OpenAI pour l'intégration avec d'autres outils :

# Run the API server
from g4f.api import run_api
run_api()

Ou via la ligne de commande :

g4f-api
# or
python -m g4f.api.run

Connectez-vous ensuite à celui-ci à l'aide du client Python OpenAI :

from openai import OpenAI

client = OpenAI(
    # Optional: Set your Hugging Face token for embeddings
    api_key="YOUR_HUGGING_FACE_TOKEN",
    base_url="http://localhost:1337/v1"
)

# Use it like the official OpenAI client
chat_completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Write a poem about a tree"}],
    stream=True,
)

for token in chat_completion:
    content = token.choices[0].delta.content
    if content is not None:
        print(content, end="", flush=True)

Modèles et fournisseurs pris en charge par GPT4Free

GPT4Free prend en charge de nombreux fournisseurs avec diverses capacités. Certains fournisseurs prennent en charge GPT-4, d'autres prennent en charge GPT-3.5 et certains prennent en charge des modèles alternatifs.

Fournisseurs GPT-4

Bing (g4f.Provider.Bing)
GeekGpt (g4f.Provider.GeekGpt)
GptChatly (g4f.Provider.GptChatly)
Liaobots (g4f.Provider.Liaobots)
Raycast (g4f.Provider.Raycast)

Fournisseurs GPT-3.5

AItianhu (g4f.Provider.AItianhu)
AItianhuSpace (g4f.Provider.AItianhuSpace)
AiAsk (g4f.Provider.AiAsk)
Aichat (g4f.Provider.Aichat)
ChatBase (g4f.Provider.ChatBase)
ChatForAi (g4f.Provider.ChatForAi)
ChatgptAi (g4f.Provider.ChatgptAi)
Et bien d'autres...

Autres modèles

Bard (Google's Palm)
DeepInfra
HuggingChat
Llama2
OpenAssistant

Conclusion

La bibliothèque Python gpt4free offre une gamme impressionnante de capacités pour accéder à divers modèles de langage sans nécessiter de clés API officielles dans de nombreux cas. En fournissant une interface unifiée pour plusieurs fournisseurs, elle permet aux développeurs d'expérimenter différents modèles de langage et de comparer leurs performances.

Bien que cette bibliothèque soit principalement une preuve de concept et puisse avoir des implications légales pour une utilisation en production, c'est un outil précieux pour apprendre les capacités de l'IA, tester de petits projets et comprendre comment différents modèles de langage fonctionnent.

N'oubliez pas d'utiliser cette bibliothèque de manière responsable, en respectant les conditions d'utilisation des fournisseurs et en étant conscient des considérations éthiques liées à l'utilisation de l'IA. Pour les applications de production, il est fortement recommandé d'utiliser des API officielles avec une authentification et des licences appropriées.

La bibliothèque est en développement actif, alors consultez le référentiel GitHub et la documentation pour les dernières fonctionnalités, les fournisseurs et les meilleures pratiques. Alors que le domaine de l'IA continue d'évoluer rapidement, des outils comme gpt4free aident à démocratiser l'accès à une technologie de pointe, permettant à davantage de développeurs d'expérimenter et d'apprendre de ces modèles puissants.

```