Como Usar a Biblioteca Python GPT4Free

Introdução

GPT4Free é uma biblioteca Python de código aberto que fornece acesso a uma coleção de poderosos modelos de linguagem através de vários provedores. Ela serve como um pacote de API de prova de conceito que demonstra solicitações de IA multi-provedor com recursos como timeouts, balanceamento de carga e controle de fluxo. Esta biblioteca permite que os desenvolvedores usem diferentes modelos de linguagem para geração de texto, incluindo variantes do GPT-3.5 e GPT-4, sem a necessidade de chaves de API oficiais em muitos casos.

Este tutorial irá guiá-lo pela instalação, configuração e uso da biblioteca gpt4free, mostrando como aproveitar suas capacidades para várias tarefas de geração de texto alimentadas por IA.

Considerações Legais

💡

AVISO: Antes de prosseguir com este tutorial, é importante entender as implicações legais de usar a biblioteca gpt4free.

Ao usar este repositório ou qualquer código relacionado, você concorda com o aviso legal fornecido pelos desenvolvedores. O autor original não se responsabiliza pelo uso deste repositório nem o endossa. O autor também não é responsável por quaisquer cópias, forks, reuploads feitos por outros usuários, ou qualquer outra coisa relacionada ao GPT4Free.

GPT4Free serve principalmente como uma prova de conceito demonstrando o desenvolvimento de um pacote de API com solicitações de múltiplos provedores. Usar esta biblioteca para contornar APIs oficiais pode violar os termos de serviço de vários provedores de IA. Antes de implantar qualquer solução baseada nesta biblioteca em um ambiente de produção, certifique-se de ter a autorização adequada e de cumprir os termos de serviço de cada provedor que você pretende usar.

Antes de mergulhar nos detalhes da implementação, vale mencionar que você pode usar o Apidog como uma excelente alternativa ao Postman para testes de API com gpt4free. O Apidog é uma plataforma abrangente de desenvolvimento de APIs que oferece recursos como design de API, depuração, testes automatizados e documentação.

Ao trabalhar com a API de interferência gpt4free, o Apidog pode te ajudar a:

Enviar solicitações para os endpoints da API
Testar diferentes configurações de parâmetros
Visualizar dados de resposta
Criar e salvar coleções de solicitações de API para uso futuro

botão

Como Instalar o GPT4Free

Pré-requisitos

Python 3.10 ou superior (recomendado)
Google Chrome (necessário para provedores com webdriver)

Métodos para Instalar o GPT4Free

Método 1: Usando PyPI

Para uma instalação completa com todos os recursos:

pip install -U g4f[all]

Para instalações parciais:

# Para o provedor OpenAI Chat
pip install -U g4f[openai]

# Para a API de interferência
pip install -U g4f[api]

# Para a interface web
pip install -U g4f[gui]

# Para geração de imagens
pip install -U g4f[image]

# Para provedores com webdriver
pip install -U g4f[webdriver]

# Para suporte a proxy
pip install -U aiohttp_socks

Método 2: Do Repositório GitHub

# Clone o repositório
git clone https://github.com/xtekky/gpt4free.git

# Navegue até o diretório do projeto
cd gpt4free

# Crie um ambiente virtual (recomendado)
python3 -m venv venv

# Ative o ambiente virtual
# No Windows:
.\venv\Scripts\activate
# No macOS e Linux:
source venv/bin/activate

# Instale os requisitos mínimos
pip install -r requirements-min.txt

# Ou instale todos os requisitos
pip install -r requirements.txt

Método 3: Usando Docker

# Puxe a imagem Docker
docker pull hlohaus789/g4f

# Execute o contêiner
docker run -p 8080:8080 -p 1337:1337 -p 7900:7900 --shm-size="2g" hlohaus789/g4f:latest

Para a versão slim (compatível com x64 e arm64):

# Crie os diretórios necessários
mkdir -p ${PWD}/har_and_cookies ${PWD}/generated_images
chown -R 1000:1000 ${PWD}/har_and_cookies ${PWD}/generated_images

# Execute a imagem Docker slim
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'

Como Usar o GPT4Free com Noções Básicas de Python

Geração de Texto com ChatCompletion

Exemplo Simples

import g4f

# Habilitar registro em log de depuração (opcional)
g4f.debug.logging = True

# Desativar verificação automática de versão (opcional)
g4f.debug.version_check = False

# Resposta normal (não streaming)
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Olá, como você está hoje?"}]
)
print(response)

Resposta em Streaming

import g4f

# Transmitir a resposta
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Escreva uma história curta sobre um robô."}],
    stream=True
)

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

Usando um Provedor Específico

import g4f

# Listar todos os provedores disponíveis que funcionam
providers = [provider.__name__ for provider in g4f.Provider.__providers__ if provider.working]
print("Provedores disponíveis:", providers)

# Usar um provedor específico
response = g4f.ChatCompletion.create(
    model="gpt-3.5-turbo",
    provider=g4f.Provider.Aichat,
    messages=[{"role": "user", "content": "Explique a computação quântica em termos simples."}]
)
print(response)

Usando a API do Cliente

Uma abordagem mais moderna usando a API do cliente:

from g4f.client import Client

# Criar uma instância do cliente
client = Client()

# Gerar texto usando conclusões de chat
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Olá"}],
    web_search=False
)
print(response.choices[0].message.content)

Geração de Imagem

from g4f.client import Client

# Criar uma instância do cliente
client = Client()

# Gerar uma imagem
response = client.images.generate(
    model="flux",
    prompt="um gato siames branco",
    response_format="url"
)
print(f"URL da imagem gerada: {response.data[0].url}")

Autenticação do Provedor

Alguns provedores exigem cookies ou tokens de acesso para autenticação:

from g4f import set_cookies

# Definir cookies para o Bing
set_cookies(".bing", {"_U": "valor do cookie"})

# Definir token de acesso para OpenAI Chat
set_cookies("chat.openai.com", {"access_token": "valor do token"})

Usando Automação de Navegador

Para provedores que requerem interação do navegador:

import g4f
from undetected_chromedriver import Chrome, ChromeOptions

# Configurar opções do Chrome
options = ChromeOptions()
options.add_argument("--incognito")

# Inicializar o WebDriver do Chrome
webdriver = Chrome(options=options, headless=True)

try:
    # Usar o navegador para várias solicitações
    for idx in range(5):
        response = g4f.ChatCompletion.create(
            model=g4f.models.default,
            provider=g4f.Provider.MyShell,
            messages=[{"role": "user", "content": f"Dê-me a ideia #{idx+1} para um aplicativo móvel."}],
            webdriver=webdriver
        )
        print(f"Ideia {idx+1}:", response)
finally:
    # Sempre feche o webdriver quando terminar
    webdriver.quit()

Suporte Assíncrono

Para melhor desempenho com várias solicitações:

import g4f
import asyncio

# Definir provedores a serem utilizados
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": "Qual é o seu nome?"}],
            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)

# Executar todos os provedores de forma assíncrona
asyncio.run(run_all())

Suporte a Proxy e Timeout

Para lidar com restrições de rede:

import g4f

# Usar com proxy específico e timeout estendido
response = g4f.ChatCompletion.create(
    model=g4f.models.default,
    messages=[{"role": "user", "content": "Como posso melhorar meu código em Python?"}],
    proxy="http://host:port",  # ou socks5://user:pass@host:port
    timeout=120  # em segundos
)
print("Resultado:", response)

Você também pode definir um proxy global através de uma variável de ambiente:

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

Executando a Interface Web com GPT4Free

GPT4Free inclui uma interface web para facilitar a interação:

from g4f.gui import run_gui
run_gui()

Alternativamente, use a linha de comando:

# Inicie o servidor Flask
python -m g4f.cli gui --port 8080 --debug

# Ou inicie o servidor FastAPI
python -m g4f --port 8080 --debug

A interface web estará disponível em http://localhost:8080/chat/

Usando a API de Interferência com GPT4Free

GPT4Free fornece uma API compatível com OpenAI para integração com outras ferramentas:

# Execute o servidor da API
from g4f.api import run_api
run_api()

Ou via linha de comando:

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

Então conecte-se a ele usando o cliente Python da OpenAI:

from openai import OpenAI

client = OpenAI(
    # Opcional: Defina seu token Hugging Face para embeddings
    api_key="SEU_TOKEN_HUGGING_FACE",
    base_url="http://localhost:1337/v1"
)

# Use como o cliente oficial da OpenAI
chat_completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Escreva um poema sobre uma árvore"}],
    stream=True,
)

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

Modelos e Provedores Suportados pelo GPT4Free

GPT4Free suporta numerosos provedores com várias capacidades. Alguns provedores suportam GPT-4, outros suportam GPT-3.5, e alguns suportam modelos alternativos.

Provedores GPT-4

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

Provedores 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)
E muitos mais...

Outros Modelos

Bard (Palm do Google)
DeepInfra
HuggingChat
Llama2
OpenAssistant

Conclusão

A biblioteca Python gpt4free oferece uma impressionante gama de capacidades para acessar vários modelos de linguagem sem exigir chaves de API oficiais em muitos casos. Ao fornecer uma interface unificada para múltiplos provedores, permite que os desenvolvedores experimentem diferentes modelos de linguagem e comparem seu desempenho.

Embora esta biblioteca seja principalmente uma prova de conceito e possa ter implicações legais para uso em produção, é uma ferramenta valiosa para aprender sobre capacidades de IA, testar pequenos projetos e entender como diferentes modelos de linguagem funcionam.

Lembre-se de usar esta biblioteca de forma responsável, respeitando os termos de serviço dos provedores e sendo consciente das considerações éticas em torno do uso de IA. Para aplicações de produção, é fortemente recomendado usar APIs oficiais com autenticação e licenciamento adequados.

A biblioteca está em desenvolvimento ativo, então verifique o repositório GitHub e a documentação para os últimos recursos, provedores e melhores práticas. À medida que o campo da IA continua a evoluir rapidamente, ferramentas como gpt4free ajudam a democratizar o acesso à tecnologia de ponta, permitindo que mais desenvolvedores experimentem e aprendam com esses poderosos modelos.