Créez votre propre agent LLM personnalisé à l'aide de modèles Open Source (llama)

Dans cet article, nous apprendrons comment créer un agent personnalisé qui utilise un llm open source (llama3.1) qui s'exécute localement sur notre PC. Nous utiliserons également Ollama et LangChain.

Contour

• Installer Ollama
• Modèle à tirer
• Servir le modèle
• Créez un nouveau dossier, ouvrez-le avec un éditeur de code
• Créer et activer un environnement virtuel
• Installer langchain langchain-ollama
• Créer un agent personnalisé avec un modèle open source en Python
• Conclusion

Installer Ollama

Suivez les instructions en fonction de votre type de système d'exploitation dans son GitHub README pour installer Ollama :

https://github.com/ollama/ollama

Je suis sur un PC basé sur Linux, je vais donc exécuter la commande suivante dans mon terminal :

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

Modèle à tirer

Récupérez le modèle LLM disponible via la commande suivante :

ollama pull llama3.1

Cela téléchargera la version balisée par défaut du modèle. En règle générale, la valeur par défaut pointe vers le modèle de paramètres de taille la plus récente et la plus petite. Dans ce cas, il s'agira du modèle lama3.1:8b.

Pour télécharger une autre version du modèle, vous pouvez vous rendre sur : https://ollama.com/library/llama3.1 et sélectionner la version à installer, puis exécuter la commande ollama pull avec le modèle et son numéro de version . Exemple : ollama pull lama3.1:70b

Sur Mac, les modèles seront téléchargés sur ~/.ollama/models

Sous Linux (ou WSL), les modèles seront stockés dans /usr/share/ollama/.ollama/models

Servir le modèle

Exécutez la commande suivante pour démarrer ollama sans exécuter l'application de bureau.

ollama serve

Tous les modèles sont automatiquement servis sur localhost:11434

Créez un nouveau dossier, ouvrez-le avec un éditeur de code

Créez un nouveau dossier sur votre ordinateur puis ouvrez-le avec un éditeur de code comme VS Code.

Créer et activer un environnement virtuel

Ouvrez le terminal. Utilisez la commande suivante pour créer un environnement virtuel .venv et activez-le :

python3 -m venv .venv

source .venv/bin/activate

Installer Langchain Langchain-ollama

Exécutez la commande suivante pour installer langchain et langchain-ollama :

pip install -U langchain langchain-ollama

La commande ci-dessus installera ou mettra à niveau les packages LangChain et LangChain-Ollama en Python. L'indicateur -U garantit que les dernières versions de ces packages sont installées, remplaçant toutes les anciennes versions éventuellement déjà présentes.

Créer un agent personnalisé avec un modèle open source en Python

Créez un fichier Python par exemple : main.py et ajoutez le code suivant :

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..')

L'extrait de code ci-dessus configure un agent LangChain utilisant le modèle ChatOllama (llama3.1) pour traiter les entrées de l'utilisateur et utiliser un outil personnalisé qui calcule la longueur des mots. Il définit un modèle d'invite pour l'agent, lie l'outil au modèle de langage et construit un agent qui traite les entrées et formate les étapes intermédiaires. Enfin, il crée un AgentExecutor pour appeler l'agent avec une entrée spécifique. Nous passons une question simple à poser "Combien de lettres dans le mot educa" puis nous imprimons le résultat ou indiquons si aucun résultat n'a été trouvé.

Lorsque nous courons, nous obtenons le résultat suivant :

> 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.

Vous voyez que l'agent a utilisé le modèle (llama3.1) pour appeler l'outil correctement afin d'obtenir le nombre de lettres dans le mot.

Conclusion

Merci d'avoir lu.

Vérifiez le dépôt Ollama ici : https://github.com/ollama/ollama

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!