Wie man die GPT4Free Python-Bibliothek verwendet

Einleitung

GPT4Free ist eine Open-Source-Python-Bibliothek, die über verschiedene Anbieter Zugriff auf eine Sammlung leistungsstarker Sprachmodelle bietet. Sie dient als Proof-of-Concept-API-Paket, das KI-Anfragen von mehreren Anbietern mit Funktionen wie Timeouts, Lastausgleich und Flusskontrolle demonstriert. Diese Bibliothek ermöglicht es Entwicklern, verschiedene Sprachmodelle für die Texterstellung zu verwenden, darunter GPT-3.5- und GPT-4-Varianten, ohne in vielen Fällen offizielle API-Schlüssel zu benötigen.

Dieses Tutorial führt Sie durch die Installation, Einrichtung und Verwendung der gpt4free-Bibliothek und zeigt Ihnen, wie Sie ihre Fähigkeiten für verschiedene KI-gestützte Texterstellungsaufgaben nutzen können.

Rechtliche Erwägungen

💡

WARNUNG: Bevor Sie mit diesem Tutorial fortfahren, ist es wichtig, die rechtlichen Auswirkungen der Verwendung der gpt4free-Bibliothek zu verstehen.

Durch die Verwendung dieses Repositorys oder eines damit verbundenen Codes stimmen Sie der vom Entwickler bereitgestellten rechtlichen Hinweise zu. Der ursprüngliche Autor ist nicht für die Verwendung dieses Repositorys verantwortlich und befürwortet es auch nicht. Der Autor ist auch nicht verantwortlich für Kopien, Forks, Re-Uploads, die von anderen Benutzern erstellt wurden, oder alles andere, was mit GPT4Free zu tun hat.

GPT4Free dient in erster Linie als Proof of Concept, der die Entwicklung eines API-Pakets mit Anfragen von mehreren Anbietern demonstriert. Die Verwendung dieser Bibliothek zur Umgehung offizieller APIs kann gegen die Nutzungsbedingungen verschiedener KI-Anbieter verstoßen. Bevor Sie eine Lösung, die auf dieser Bibliothek basiert, in einer Produktionsumgebung einsetzen, stellen Sie sicher, dass Sie die entsprechende Genehmigung haben und die Nutzungsbedingungen jedes Anbieters einhalten, den Sie verwenden möchten.

Bevor Sie in die Implementierungsdetails eintauchen, ist es erwähnenswert, dass Sie Apidog als eine ausgezeichnete Alternative zu Postman für API-Tests mit gpt4free verwenden können. Apidog ist eine umfassende API-Entwicklungsplattform, die Funktionen wie API-Design, Debugging, automatisierte Tests und Dokumentation bietet.

Bei der Arbeit mit der gpt4free-Interferenz-API kann Apidog Ihnen helfen:

Anfragen an die API-Endpunkte senden
Verschiedene Parameterkonfigurationen testen
Antwortdaten visualisieren
Sammlungen von API-Anfragen für die zukünftige Verwendung erstellen und speichern

button

So installieren Sie GPT4Free

Voraussetzungen

Python 3.10 oder höher (empfohlen)
Google Chrome (erforderlich für Anbieter mit Webdriver)

Methoden zur Installation von GPT4Free

Methode 1: Verwendung von PyPI

Für eine vollständige Installation mit allen Funktionen:

pip install -U g4f[all]

Für Teilinstallationen:

# 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

Methode 2: Vom GitHub-Repository

# 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

Methode 3: Verwendung von 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

Für die schlanke Version (kompatibel mit x64 und 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'

So verwenden Sie GPT4Free mit Python-Grundlagen

Texterstellung mit ChatCompletion

Einfaches Beispiel

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)

Streaming-Antwort

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)

Verwenden eines bestimmten Anbieters

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)

Verwenden der Client-API

Ein modernerer Ansatz mit der Client-API:

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)

Bilderzeugung

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

Anbieterauthentifizierung

Einige Anbieter benötigen Cookies oder Zugriffstoken zur Authentifizierung:

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

Verwenden der Browserautomatisierung

Für Anbieter, die eine Browserinteraktion erfordern:

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

Asynchrone Unterstützung

Für verbesserte Leistung bei mehreren Anfragen:

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

Proxy- und Timeout-Unterstützung

Für die Behandlung von Netzwerkbeschränkungen:

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)

Sie können auch einen globalen Proxy über eine Umgebungsvariable festlegen:

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

Ausführen der Weboberfläche mit GPT4Free

GPT4Free enthält eine Weboberfläche für eine einfachere Interaktion:

from g4f.gui import run_gui
run_gui()

Alternativ können Sie die Befehlszeile verwenden:

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

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

Die Weboberfläche ist unter http://localhost:8080/chat/ verfügbar

Verwenden der Interferenz-API mit GPT4Free

GPT4Free bietet eine OpenAI-kompatible API zur Integration mit anderen Tools:

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

Oder über die Befehlszeile:

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

Stellen Sie dann mit dem OpenAI-Python-Client eine Verbindung her:

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)

GPT4Free unterstützte Modelle & Anbieter

GPT4Free unterstützt zahlreiche Anbieter mit verschiedenen Fähigkeiten. Einige Anbieter unterstützen GPT-4, andere GPT-3.5 und einige alternative Modelle.

GPT-4-Anbieter

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

GPT-3.5-Anbieter

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)
Und viele mehr...

Andere Modelle

Bard (Google's Palm)
DeepInfra
HuggingChat
Llama2
OpenAssistant

Schlussfolgerung

Die gpt4free-Python-Bibliothek bietet eine beeindruckende Bandbreite an Möglichkeiten für den Zugriff auf verschiedene Sprachmodelle, ohne in vielen Fällen offizielle API-Schlüssel zu benötigen. Durch die Bereitstellung einer einheitlichen Schnittstelle für mehrere Anbieter ermöglicht sie Entwicklern, mit verschiedenen Sprachmodellen zu experimentieren und deren Leistung zu vergleichen.

Obwohl diese Bibliothek in erster Linie ein Proof of Concept ist und rechtliche Auswirkungen für die Produktion haben kann, ist sie ein wertvolles Werkzeug, um mehr über KI-Fähigkeiten zu erfahren, kleine Projekte zu testen und zu verstehen, wie verschiedene Sprachmodelle funktionieren.

Denken Sie daran, diese Bibliothek verantwortungsvoll zu verwenden, die Nutzungsbedingungen der Anbieter zu respektieren und die ethischen Aspekte der KI-Nutzung zu berücksichtigen. Für Produktionsanwendungen wird dringend empfohlen, offizielle APIs mit ordnungsgemäßer Authentifizierung und Lizenzierung zu verwenden.

Die Bibliothek befindet sich in aktiver Entwicklung, also überprüfen Sie das GitHub-Repository und die Dokumentation auf die neuesten Funktionen, Anbieter und Best Practices. Da sich das Gebiet der KI rasant weiterentwickelt, tragen Tools wie gpt4free dazu bei, den Zugang zu Spitzentechnologie zu demokratisieren, sodass mehr Entwickler mit diesen leistungsstarken Modellen experimentieren und von ihnen lernen können.