Construire des agents d’IA avec Llama.cpp

Image par auteur

Llama.cpp est le cadre original et hautes performances qui alimente de nombreux outils d’IA locaux populaires, notamment Olllama, les chatbots locaux et d’autres solutions LLM sur les appareils. En travaillant directement avec llama.cpp, vous pouvez minimiser les frais généraux, obtenir un contrôle à grain fin et optimiser les performances pour votre matériel spécifique, rendre vos agents et applications d’IA locaux plus rapidement et plus configurables

Dans ce tutoriel, je vous guiderai à travers la création d’applications AI à l’aide de LLAMA.cpp, une bibliothèque C / C ++ puissante pour exécuter efficacement les modèles de grands langues (LLMS). Nous couvrirons la configuration d’un serveur LLAMA.CPP, l’intégrerons à Langchain et la création d’un agent React capable d’utiliser des outils comme la recherche Web et un Python REPL.

1. Configuration du serveur lama.cpp

Cette section couvre l’installation de llama.cpp et de ses dépendances, la configurer pour le support CUDA, la création des binaires nécessaires et l’exécution du serveur.

Note: Nous utilisons une carte graphique NVIDIA RTX 4090 fonctionnant sur un système d’exploitation Linux avec la boîte à outils CUDA pré-configurée. Si vous n’avez pas accès à un matériel local similaire, vous pouvez louer des instances GPU à partir de Vaste.ai pour un prix moins cher.

Capture d’écran de Vast.ai | Console

1. Mettez à jour la liste des packages de votre système et installez des outils essentiels comme Build-Essential, Cmake, Curl et Git. PciUtils est inclus pour les informations matérielles, et Libcurl4-OpenSSL-DEV est nécessaire pour que Llama.cpp télécharge des modèles à partir de Face Hugging.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev git -y

2. Clone le référentiel officiel lama.cpp de GitHub et utilisez CMake pour configurer la version.

# Clone llama.cpp repository
git clone https://github.com/ggml-org/llama.cpp

# Configure build with CUDA support
cmake llama.cpp -B llama.cpp/build 
    -DBUILD_SHARED_LIBS=OFF 
    -DGGML_CUDA=ON 
    -DLLAMA_CURL=ON

3. Compiler lama.cpp et tous ses outils, y compris le serveur. Pour plus de commodité, copiez tous les binaires compilés du lama.cpp / build / bin / répertoire au répertoire principal lama.cpp /.

# Build all necessary binaries including server
cmake --build llama.cpp/build --config Release -j --clean-first

# Copy all binaries to main directory
cp llama.cpp/build/bin/* llama.cpp/

4. Démarrez le serveur LLAMA.CPP avec un modèle UNSLOTK / GEMMA-3-4B-IT-GGUF.

./llama.cpp/llama-server 
    -hf unsloth/gemma-3-4b-it-GGUF:Q4_K_XL 
    --host 0.0.0.0 
    --port 8000 
    --n-gpu-layers 999 
    --ctx-size 8192 
    --threads $(nproc) 
    --temp 0.6 
    --cache-type-k q4_0 
    --jinja

5. Vous pouvez tester si le serveur s’exécute correctement en envoyant une demande de poste à l’aide de Curl.

(main) root@C.20841134:/workspace$ curl -X POST http://localhost:8000/v1/chat/completions 
    -H "Content-Type: application/json" 
    -d '{
        "messages": (
            {"role": "user", "content": "Hello! How are you today?"}
        ),
        "max_tokens": 150,
        "temperature": 0.7
    }'

Sortir:

{"choices":({"finish_reason":"length","index":0,"message":{"role":"assistant","content":"nOkay, user greeted me with a simple "Hello! How are you today?" nnHmm, this seems like a casual opening. The user might be testing the waters to see if I respond naturally, or maybe they genuinely want to know how an AI assistant conceptualizes "being" but in a friendly way. nnI notice they used an exclamation mark, which feels warm and possibly playful. Maybe they're in a good mood or just trying to make conversation feel less robotic. nnSince I don't have emotions, I should clarify that gently but still keep it warm. The response should acknowledge their greeting while explaining my nature as an AI. nnI wonder if they're asking because they're curious about AI consciousness, or just being polite"}}),"created":1749319250,"model":"gpt-3.5-turbo","system_fingerprint":"b5605-5787b5da","object":"chat.completion","usage":{"completion_tokens":150,"prompt_tokens":9,"total_tokens":159},"id":"chatcmpl-jNfif9mcYydO2c6nK0BYkrtpNXSnseV1","timings":{"prompt_n":9,"prompt_ms":65.502,"prompt_per_token_ms":7.278,"prompt_per_second":137.40038472107722,"predicted_n":150,"predicted_ms":1207.908,"predicted_per_token_ms":8.052719999999999,"predicted_per_second":124.1816429728092}}

2. Construire un agent AI avec Langgraph et Llama.cpp

Maintenant, utilisons Langgraph et Langchain pour interagir avec le serveur LLAMA.CPP et créer un agent AI multi-outils.

1. Définissez votre clé API Tavily pour les capacités de recherche.
2. Pour que Langchain travaille avec le serveur local llama.cpp (qui émule une API OpenAI), vous pouvez définir OpenAI_API_KEY sur une chaîne locale ou non empty, car la base_url dirigera les demandes localement.

export TAVILY_API_KEY="your_api_key_here"
export OPENAI_API_KEY=local

3. Installez les bibliothèques Python nécessaires: Langgraph pour la création d’agents, Tavily-Python pour l’outil de recherche Tavily et divers packages Langchain pour les interactions et outils LLM.

%%capture
!pip install -U 
    langgraph tavily-python langchain langchain-community langchain-experimental langchain-openai

4. Configurez Chatopenai de Langchain pour communiquer avec votre serveur LLAMA.CPP local.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="unsloth/gemma-3-4b-it-GGUF:Q4_K_XL",   
    temperature=0.6,
    base_url="http://localhost:8000/v1",         
)

5. Configurez les outils que votre agent pourra utiliser.
   • TavilySearchResults: Permet à l’agent de rechercher le Web.
   • PythonRepltool: Fournit à l’agent une boucle Python Read-Eval-Print pour exécuter du code.

from langchain_community.tools import TavilySearchResults
from langchain_experimental.tools.python.tool import PythonREPLTool

search_tool = TavilySearchResults(max_results=5, include_answer=True)
code_tool   = PythonREPLTool()

tools = (search_tool, code_tool)

6. Utilisez la fonction CREATE_REACT_AGENT Pré-construite de Langgraph pour créer un agent qui peut raisonner et agir (React Framework) à l’aide du LLM et des outils définis.

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=llm,
    tools=tools,
)

3. Testez l’agent AI avec d’exemples de requêtes

Maintenant, nous allons tester l’agent AI et afficher également les outils que l’agent utilise.

1. Cette fonction d’assistance extrait les noms des outils utilisés par l’agent de l’historique de conversation. Ceci est utile pour comprendre le processus décisionnel de l’agent.

def extract_tool_names(conversation: dict) -> list(str):
    tool_names = set()
    for msg in conversation.get('messages', ()):
        calls = ()
        if hasattr(msg, 'tool_calls'):
            calls = msg.tool_calls or ()
        elif isinstance(msg, dict):
            calls = msg.get('tool_calls') or ()
            if not calls and isinstance(msg.get('additional_kwargs'), dict):
                calls = msg('additional_kwargs').get('tool_calls', ())
        else:
            ak = getattr(msg, 'additional_kwargs', None)
            if isinstance(ak, dict):
                calls = ak.get('tool_calls', ())
        for call in calls:
            if isinstance(call, dict):
                if 'name' in call:
                    tool_names.add(call('name'))
                elif 'function' in call and isinstance(call('function'), dict):
                    fn = call('function')
                    if 'name' in fn:
                        tool_names.add(fn('name'))
    return sorted(tool_names)

2. Définissez une fonction pour exécuter l’agent avec une question donnée et imprimer les outils utilisés et la réponse finale.

def run_agent(question: str):
    result = agent.invoke({"messages": ({"role": "user", "content": question})})
    raw_answer = result("messages")(-1).content
    tools_used = extract_tool_names(result)
    return tools_used, raw_answer

3. Demandons à l’agent les 5 meilleures nouvelles de rupture. Il doit utiliser l’outil Tavily_Search_Results_Json.

tools, answer = run_agent("What are the top 5 breaking news stories?")
print("Tools used ➡️", tools)
print(answer)

Sortir:

Tools used ➡️ ('tavily_search_results_json')
Here are the top 5 breaking news stories based on the provided sources:

1.  **Gaza Humanitarian Crisis:** Ongoing conflict and challenges in Gaza, including the Eid al-Adha holiday, and the retrieval of a Thai hostage's body.
2.  **Russian Drone Attacks on Kharkiv:** Russia continues to target Ukrainian cities with drone and missile strikes.
3.  **Wagner Group Departure from Mali:** The Wagner Group is leaving Mali after heavy losses, but Russia's Africa Corps remains.
4.  **Trump-Musk Feud:** A dispute between former President Trump and Elon Musk could have implications for Tesla stock and the U.S. space program.
5.  **Education Department Staffing Cuts:** The Biden administration is seeking Supreme Court intervention to block planned staffing cuts at the Education Department.

4. Demandez à l’agent d’écrire et d’exécuter du code Python pour la série Fibonacci. Il doit utiliser l’outil Python_Repl.

tools, answer = run_agent(
    "Write a code for the Fibonacci series and execute it using Python REPL."
)
print("Tools used ➡️", tools)
print(answer)

Sortir:

Tools used ➡️ ('Python_REPL')
The Fibonacci series up to 10 terms is (0, 1, 1, 2, 3, 5, 8, 13, 21, 34).

Réflexions finales

Dans ce guide, j’ai utilisé un petit LLM quantifié, qui lutte parfois avec la précision, surtout en ce qui concerne la sélection des outils. Si votre objectif est de construire des agents d’IA prêts pour la production, je recommande fortement de gérer les derniers modèles de taille complète avec llama.cpp. Les modèles plus grands et plus récents fournissent généralement de meilleurs résultats et des sorties plus fiables

Il est important de noter que la configuration de Llama.cpp peut être plus difficile par rapport aux outils conviviaux comme Olllama. Cependant, si vous êtes prêt à investir le temps de déboguer, d’optimiser et de tailler llama.cpp pour votre matériel spécifique, les gains de performances et la flexibilité en valent la peine.

L’un des plus grands avantages de Llama.cpp est son efficacité: vous n’avez pas besoin de matériel haut de gamme pour commencer. Il fonctionne bien sur des processeurs et des ordinateurs portables réguliers sans GPU dédiés, ce qui rend l’IA local accessible à presque tout le monde. Et si vous avez besoin de plus d’énergie, vous pouvez toujours louer une instance GPU abordable d’un fournisseur de cloud.

Abid Ali Awan (@ 1abidaliawan) est un professionnel certifié des data scientifiques qui aime construire des modèles d’apprentissage automatique. Actuellement, il se concentre sur la création de contenu et la rédaction de blogs techniques sur l’apprentissage automatique et les technologies de science des données. Abid est titulaire d’une maîtrise en gestion technologique et d’un baccalauréat en génie des télécommunications. Sa vision est de construire un produit d’IA en utilisant un réseau de neurones graphiques pour les étudiants aux prises avec une maladie mentale.