Desvendando a GenAI - Parte 6

Vamos melhorar a legibilidade e modularidade do nosso código usando a biblioteca `ell`. O objetivo é simplificar o código gerado e tornar a interação com a OpenAI API mais intuitiva!

É importante ler a parte 5 antes de seguir com a parte 6!

Desvendando a GenAI - Parte 5

O que você vai aprender:

1. Como usar a biblioteca `ell` para modularizar o código.

2. Como utilizar decorators para simplificar a definição de interações com modelos LLMs.

3. Melhorar a legibilidade do código mantendo as boas práticas de desenvolvimento.

Vamos começar!

Passo 1: Instalação e Preparação

Primeiro, você precisa instalar a biblioteca `ell` e outras dependências necessárias, como o `python-dotenv` para carregar variáveis de ambiente e o `openai` para interagir com a API da OpenAI.

1. Instale as dependências:

pip install openai python-dotenv ell

2. Em seguida, crie um arquivo `.env` na raiz do seu projeto e adicione sua chave de API da OpenAI:

OPENAI_SERVICE_ACCOUNT_KEY=your_api_key_here

Você pode obter sua chave de API na plataforma OpenAI (https://platform.openai.com).

Agora, vamos carregar essa chave de API e configurar a biblioteca `ell` em nosso código Python.

Passo 2: Importando e Configurando as Bibliotecas

import os
import ell
from dotenv import load_dotenv
from openai import OpenAI

# Carregando variáveis de ambiente
load_dotenv(r".env")
OPENAI_SERVICE_ACCOUNT_KEY = os.getenv("OPENAI_SERVICE_ACCOUNT_KEY")

# Iniciando a biblioteca ell com a flag verbose True para mensagens de debug mais intuitivas

client = OpenAI(api_key=OPENAI_SERVICE_ACCOUNT_KEY)

ell.init(verbose=True, default_client=client)

Aqui estamos configurando o ambiente e a biblioteca `ell` para interagir com a OpenAI API. A flag `verbose=True` permite que as mensagens de debug fiquem mais detalhadas e fáceis de entender.

Passo 3: Simplificando Funções com `ell.simple`

A grande vantagem de usar a biblioteca `ell` é a simplificação da definição de interações com LLMs. Vamos criar duas versões de uma função simples de saudação, `hello`, para mostrar como o código fica mais limpo.

Função 1: Usando DocString como System Prompt

@ell.simple(model="gpt-4o-mini", max_tokens=100, client=client)
def hello(name: str):
    """Você é um assistente gentil e prestativo."""  # System prompt
    return f"Diga olá para {name}!"  # User prompt

Neste exemplo, estamos utilizando o decorator `@ell.simple` para definir que essa função usará o modelo `gpt-4o-mini` e terá um limite de 100 tokens na resposta. O `ell.simple` cuida automaticamente da formatação do input e do output. A docstring """Você é um assistente gentil e prestativo.""" é utilizada como o system prompt, enquanto o retorno da função serve como o user prompt.

Função 2: Usando `ell.system` e `ell.user` Explicitamente

Agora, vamos ver uma forma de ser mais explícito na definição dos prompts utilizando as funções `ell.system()` e `ell.user()`.

@ell.simple(model="gpt-4o-mini", client=client)
def hello2(name: str):
    return [
        ell.system("Você é um assistente gentil e prestativo."),
        ell.user(f"Diga olá para {name}!"),
    ]

Aqui, estamos criando explicitamente o system prompt e o user prompt utilizando `ell.system()` e `ell.user()`, o que nos dá mais controle sobre a interação.

Passo 4: Testando as Funções

Agora que temos nossas funções definidas, vamos testá-las e ver o que a biblioteca `ell` retorna.

world = hello("Mundo")
print(world)
world = hello2("Mundo")
print(world)

Resultado Esperado

As duas funções devem retornar algo como:

Diga olá para Mundo!

Vantagens da Abordagem

• Código mais limpo e legível: Ao usar a biblioteca `ell`, o código fica mais conciso e fácil de entender. Não precisamos mais nos preocupar em formatar o input ou fazer parsing do output.

• Modularização: Usamos decorators e funções da biblioteca para separar claramente as responsabilidades de cada parte do código, tornando-o mais fácil de manter e expandir.

• Interações diretas: A biblioteca simplifica a interação com os modelos, tornando as chamadas mais intuitivas e sem a necessidade de lidar com detalhes complexos de API.

Passo 5: Considerações Finais

A biblioteca `ell` é uma ferramenta poderosa para simplificar o uso de LLMs como o GPT. Ela oferece uma forma de escrever código mais limpo e fácil de entender, sem perder a flexibilidade de personalizar as interações com os modelos.

Se você deseja explorar mais sobre como usar o `ell` ou outras bibliotecas para trabalhar com LLMs, consulte a documentação oficial do `ell` (https://ell.readthedocs.io/).

Conclusão

Neste tutorial, você aprendeu como melhorar a legibilidade do seu código usando a biblioteca `ell` para simplificar interações com o modelo GPT-4. O uso de decorators e funções específicas para definir os prompts torna o código mais modular e de fácil manutenção.

Agora, experimente modificar as funções para diferentes tipos de interações ou até mesmo combinar com outras LLMs! A biblioteca `ell` torna o desenvolvimento com IA muito mais acessível e agradável.

Fique à vontade para deixar suas dúvidas nos comentários e compartilhar suas experiências!

O código fonte pode ser encontrado aqui!