Cómo usar la biblioteca de Python GPT4Free

Introducción

GPT4Free es una biblioteca de Python de código abierto que proporciona acceso a una colección de modelos de lenguaje potentes a través de varios proveedores. Sirve como un paquete API de prueba de concepto que demuestra solicitudes de IA de múltiples proveedores con características como tiempos de espera, equilibrio de carga y control de flujo. Esta biblioteca permite a los desarrolladores utilizar diferentes modelos de lenguaje para la generación de texto, incluidas las variantes GPT-3.5 y GPT-4, sin la necesidad de claves API oficiales en muchos casos.

Este tutorial lo guiará a través de la instalación, configuración y uso de la biblioteca gpt4free, mostrándole cómo aprovechar sus capacidades para diversas tareas de generación de texto impulsadas por IA.

Consideraciones legales

💡

ADVERTENCIA: Antes de continuar con este tutorial, es importante comprender las implicaciones legales del uso de la biblioteca gpt4free.

Al utilizar este repositorio o cualquier código relacionado con él, acepta el aviso legal proporcionado por los desarrolladores. El autor original no es responsable del uso de este repositorio ni lo respalda. El autor tampoco es responsable de ninguna copia, bifurcación, re-subida realizada por otros usuarios, ni de ninguna otra cosa relacionada con GPT4Free.

GPT4Free sirve principalmente como una prueba de concepto que demuestra el desarrollo de un paquete API con solicitudes de múltiples proveedores. El uso de esta biblioteca para eludir las API oficiales puede violar los términos de servicio de varios proveedores de IA. Antes de implementar cualquier solución basada en esta biblioteca en un entorno de producción, asegúrese de tener la autorización adecuada y de cumplir con los términos de servicio de cada proveedor que pretenda utilizar.

Antes de profundizar en los detalles de la implementación, vale la pena mencionar que puede utilizar Apidog como una excelente alternativa a Postman para las pruebas de API con gpt4free. Apidog es una plataforma integral de desarrollo de API que ofrece funciones como diseño de API, depuración, pruebas automatizadas y documentación.

Cuando trabaje con la API de interferencia gpt4free, Apidog puede ayudarle a:

Enviar solicitudes a los puntos finales de la API
Probar diferentes configuraciones de parámetros
Visualizar los datos de respuesta
Crear y guardar colecciones de solicitudes de API para uso futuro

button

Cómo instalar GPT4Free

Requisitos previos

Python 3.10 o superior (recomendado)
Google Chrome (requerido para proveedores con webdriver)

Métodos para instalar GPT4Free

Método 1: Usando PyPI

Para una instalación completa con todas las funciones:

pip install -U g4f[all]

Para instalaciones parciales:

# 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étodo 2: Desde el repositorio de 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étodo 3: Usando 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

Para la versión slim (compatible con x64 y 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'

Cómo usar GPT4Free con conceptos básicos de Python

Generación de texto con ChatCompletion

Ejemplo 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)

Respuesta de transmisión

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)

Usando un proveedor específico

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)

Usando la API del cliente

Un enfoque más moderno usando la API del cliente:

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)

Generación de imágenes

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}")

Autenticación del proveedor

Algunos proveedores requieren cookies o tokens de acceso para la autenticación:

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"})

Usando la automatización del navegador

Para proveedores que requieren interacción con el navegador:

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()

Soporte asíncrono

Para mejorar el rendimiento con múltiples solicitudes:

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())

Soporte de proxy y tiempo de espera

Para manejar las limitaciones de la red:

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)

También puede establecer un proxy global a través de una variable de entorno:

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

Ejecutando la interfaz web con GPT4Free

GPT4Free incluye una interfaz web para una interacción más fácil:

from g4f.gui import run_gui
run_gui()

Alternativamente, use la línea de comandos:

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

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

La interfaz web estará disponible en http://localhost:8080/chat/

Usando la API de interferencia con GPT4Free

GPT4Free proporciona una API compatible con OpenAI para la integración con otras herramientas:

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

O a través de la línea de comandos:

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

Luego conéctese a él usando el cliente Python de 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)

Modelos y proveedores compatibles con GPT4Free

GPT4Free admite numerosos proveedores con diversas capacidades. Algunos proveedores admiten GPT-4, otros admiten GPT-3.5 y algunos admiten modelos alternativos.

Proveedores de GPT-4

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

Proveedores de 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)
Y muchos más...

Otros modelos

Bard (Palm de Google)
DeepInfra
HuggingChat
Llama2
OpenAssistant

Conclusión

La biblioteca de Python gpt4free ofrece una impresionante gama de capacidades para acceder a varios modelos de lenguaje sin requerir claves API oficiales en muchos casos. Al proporcionar una interfaz unificada para múltiples proveedores, permite a los desarrolladores experimentar con diferentes modelos de lenguaje y comparar su rendimiento.

Si bien esta biblioteca es principalmente una prueba de concepto y puede tener implicaciones legales para el uso en producción, es una herramienta valiosa para aprender sobre las capacidades de la IA, probar pequeños proyectos y comprender cómo funcionan los diferentes modelos de lenguaje.

Recuerde utilizar esta biblioteca de manera responsable, respetando los términos de servicio de los proveedores y teniendo en cuenta las consideraciones éticas en torno al uso de la IA. Para las aplicaciones de producción, se recomienda encarecidamente utilizar las API oficiales con la autenticación y las licencias adecuadas.

La biblioteca está en desarrollo activo, así que consulte el repositorio de GitHub y la documentación para conocer las últimas funciones, proveedores y mejores prácticas. A medida que el campo de la IA continúa evolucionando rápidamente, herramientas como gpt4free ayudan a democratizar el acceso a la tecnología de vanguardia, permitiendo que más desarrolladores experimenten y aprendan de estos poderosos modelos.