Neste artigo, aprenderemos como criar um agente personalizado que usa um llm de código aberto (llama3.1) que é executado localmente em nosso PC. Também usaremos Ollama e LangChain.

Contorno

• Instale o Ollama
• Modelo de extração
• Modelo de serviço
• Crie uma nova pasta, abra-a com um editor de código
• Criar e ativar ambiente virtual
• Instale langchain langchain-ollama
• Construa um agente personalizado com modelo de código aberto em Python
• Conclusão

Instalar Ollama

Siga as instruções com base no tipo de sistema operacional em seu GitHub README para instalar o Ollama:

https://github.com/ollama/ollama

Estou em um PC baseado em Linux, então vou executar o seguinte comando em meu terminal:

curl -fsSL https://ollama.com/install.sh | sh

Modelo puxado

Busque o modelo LLM disponível por meio do seguinte comando:

ollama pull llama3.1

Isso fará o download da versão com tag padrão do modelo. Normalmente, o padrão aponta para o modelo de parâmetro de menor tamanho mais recente. Neste caso, será o modelo llama3.1:8b.

Para baixar outra versão do modelo, você pode acessar: https://ollama.com/library/llama3.1 e selecionar a versão a ser instalada, e então executar o comando ollama pull com o modelo e seu número de versão . Exemplo: ollama pull lhama3.1:70b

No Mac, os modelos serão baixados em ~/.ollama/models

No Linux (ou WSL), os modelos serão armazenados em /usr/share/ollama/.ollama/models

Modelo de serviço

Execute o seguinte comando para iniciar o ollama sem executar o aplicativo de desktop.

ollama serve

Todos os modelos são servidos automaticamente em localhost:11434

Crie uma nova pasta, abra-a com um editor de código

Crie uma nova pasta em seu computador e abra-a com um editor de código como o VS Code.

Criar e ativar ambiente virtual

Abra o terminal. Use o seguinte comando para criar um ambiente virtual .venv e ativá-lo:

python3 -m venv .venv

source .venv/bin/activate

Instale langchain langchain-ollama

Execute o seguinte comando para instalar langchain e langchain-ollama:

pip install -U langchain langchain-ollama

O comando acima irá instalar ou atualizar os pacotes LangChain e LangChain-Ollama em Python. O sinalizador -U garante que as versões mais recentes desses pacotes sejam instaladas, substituindo quaisquer versões mais antigas que já possam estar presentes.

Crie um agente personalizado com modelo de código aberto em Python

Crie um arquivo Python por exemplo: main.py e adicione o seguinte código:

from langchain_ollama import ChatOllama
from langchain.agents import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents.format_scratchpad.openai_tools import (
    format_to_openai_tool_messages,
)
from langchain.agents import AgentExecutor
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser


llm = ChatOllama(
            model="llama3.1",
            temperature=0,
            verbose=True
        )

@tool
def get_word_length(word: str) -> int:
    """Returns the length of a word."""
    return len(word)


tools = [get_word_length]



prompt = ChatPromptTemplate.from_messages(
            [
                (
                    "system",
                    "You are very powerful assistant",
                ),
                ("user", "{input}"),
                MessagesPlaceholder(variable_name="agent_scratchpad"),
            ]
        )

llm_with_tools = llm.bind_tools(tools)

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

# Create an agent executor by passing in the agent and tools
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.invoke({"input": "How many letters in the word educa"})

if result:
    print(f"[Output] --> {result['output']}")
else:
    print('There are no result..')

O trecho de código acima configura um agente LangChain usando o modelo ChatOllama (llama3.1) para processar a entrada do usuário e utilizar uma ferramenta personalizada que calcula o comprimento da palavra. Ele define um modelo de prompt para o agente, vincula a ferramenta ao modelo de linguagem e constrói um agente que processa a entrada e formata as etapas intermediárias. Por fim, cria um AgentExecutor para invocar o agente com uma entrada específica. Passamos uma pergunta simples para perguntar "Quantas letras tem a palavra educa" e depois imprimimos o resultado ou indicamos se nenhum resultado foi encontrado.

Quando executamos, obtemos o seguinte resultado:

> Entering new AgentExecutor chain...

Invoking: `get_word_length` with `{'word': 'educa'}`


5The word "educa" has 5 letters.

> Finished chain.
[Output] --> The word "educa" has 5 letters.

Você vê que o agente usou o modelo (llama3.1) para chamar a ferramenta corretamente para obter a contagem de letras na palavra.

Conclusão

Obrigado pela leitura.

Verifique o repositório Ollama aqui: https://github.com/ollama/ollama