Blog
Exécuter Llama 3, Mixtral et GPT-4o

Exécuter Llama 3, Mixtral et GPT-4o

May 15, 20248 min read

Il existe tellement de façons différentes d’exécuter la partie G-Generation du RAG ! Aujourd’hui, je vais montrer quelques façons d’exécuter certains des concurrents les plus en vue dans ce domaine : Llama 3 de Meta, Mixtral de Mistral, et le GPT-4o récemment annoncé par OpenAI.

Comme nous pouvons le voir dans le classement LMSYS ci-dessous, l’écart (en bleu clair) entre les modèles closed-source et les modèles open-source vient de se creuser cette semaine avec la nouvelle annonce d’OpenAI.

closed-source vs open

Source de l’image : https://twitter.com/maximelabonne basée sur https://chat.lmsys.org/?leaderboard.

Plan de ce blog :

Les façons les plus rapides d’exécuter Llama 3 ou Mixtral open-source
- Localement avec Ollama
- Endpoints Anyscale
- Endpoint OctoAI
- Endpoint Groq
Exécuter le dernier gpt-4o d’OpenAI
Évaluer les réponses : GPT-4o, Llama 3, Mixtral

Commençons !

Exécuter Llama 3 localement avec Ollama

Tout d’abord, exécutez le RAG de la manière habituelle, jusqu’à la dernière étape, où vous générez la réponse, la partie G du RAG. Nous avons de nombreux tutoriels pour démarrer avec le RAG, y compris celui-ci en Python.

Pour exécuter Llama 3 localement avec Ollama.

Suivez les instructions pour installer ollama et télécharger un modèle.
Cette page indique que ollama run llama3 téléchargera par défaut le dernier modèle "instruct", qui est affiné pour les cas d’utilisation de chat/dialogue ET tient sur votre ordinateur. Exécutez cette commande.
Pour Python, pip install ollama.
Dans votre code Python RAG, définissez un Prompt et une Question, puis invoquez l’appel API vers votre modèle Llama 3 installé localement.

Dans mon cas, j’ai un ordinateur portable M2 avec 16 Go de mémoire, donc le modèle Ollama téléchargé est la version la plus quantifiée compilée en gguf de Llama3-8B. Autrement dit, une très petite version de Llama 3 est maintenant installée sur mon ordinateur portable !

# Separate all the context together by space, reverse order.
# See “Lost in the middle” arxiv.org paper.
contexts_combined = ' '.join(reversed(contexts))
source_combined = ' '.join(reversed(sources))

# Define a Prompt.
SYSTEM_PROMPT = f"""Given the provided Context, your task is to
understand the content and accurately answer the question based
on the information available in the context. 
Provide a complete, clear, concise, relevant response in fewer
than 4 sentences and cite the unique Sources.
Answer: The answer to the question.
Sources: {source_combined}
Context: {contexts_combined}
"""

# Send the Question and Prompt to local! llama 3 chat.
import ollama
start_time = time.time()
response = ollama.chat(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model='llama3',
   stream=False,
   options={"temperature": TEMPERATURE, "seed": RANDOM_SEED,
            "top_p": TOP_P,
           #  "max_tokens": MAX_TOKENS, # not recognized
            "frequency_penalty": FREQUENCY_PENALTY}
)

ollama_llama3_time = time.time() - start_time
pprint.pprint(response['message']['content'].replace('\n', ' '))
print(f"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds")

La réponse semble plutôt bonne ; je vois trois paramètres, mais seule la citation semble brouillée. Le modèle local a mis 13 secondes à exécuter l’inférence sur mon ordinateur portable, mais le coût était nul.

Exécuter Llama 3 depuis les endpoints Anyscale

Pour exécuter l’inférence de Llama 3 depuis les endpoints Anyscale :

Suivez les instructions sur la page github des endpoints Anyscale pour installer la ligne de commande, puis installez le plugin.
Obtenez votre jeton API d’endpoint Anysclae et mettez à jour vos variables d’environnement.
Pour Python, pip install openai.
Lisez à propos du modèle Llama 3 téléchargé depuis HuggingFace et invoquez-le à l’aide de l’API OpenAI. J’ai utilisé le Llama 3 par défaut sur Anyscale playground, qui était un modèle 70B-Instruct.

import openai

LLM_NAME = "meta-llama/Llama-3-70b-chat-hf"

anyscale_client = openai.OpenAI(
   base_url = "https://api.endpoints.anyscale.com/v1",
   api_key=os.environ.get("ANYSCALE_ENPOINT_KEY"),
)

start_time = time.time()
response = anyscale_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_anyscale_endpoints_time = time.time() - start_time

# Print the response.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_anyscale_endpoints_time: {format(llama3_anyscale_endpoints_time, '.2f')} seconds")

La réponse semble bonne, avec une citation parfaite. Le Llama 3 70B de HuggingFace a mis ~6 secondes à être invoqué depuis les endpoints Anyscale.

Exécuter Llama 3 depuis les endpoints OctoAI

Pour exécuter l’inférence Llama 3 depuis les endpoints OctoAI :

Allez sur https://octoai.cloud/text, choisissez le modèle Llama 3 8B, cliquez sur le lien du modèle et vous verrez un exemple de code.
Obtenez votre jeton d’API d’endpoint OctoAI et mettez à jour vos variables d’environnement.
Pour Python, pip install octoai.
Lisez à propos du modèle Llama 3 8B téléchargé depuis Meta et invoquez-le.


from octoai.text_gen import ChatMessage
from octoai.client import OctoAI

LLM_NAME = "meta-llama-3-70b-instruct"

octoai_client = OctoAI(
   api_key=os.environ.get("OCTOAI_TOKEN"),
)

start_time = time.time()
response = octoai_client.text_gen.create_chat_completion(
   messages=[
       ChatMessage(
           content=SYSTEM_PROMPT,
           role="system"
       ),
       ChatMessage(
           content=SAMPLE_QUESTION,
           role="user"
       )
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   # seed=RANDOM_SEED, # not recognized
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_octai_endpoints_time = time.time() - start_time

# Print the response.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_octai_endpoints_time: {format(llama3_octai_endpoints_time, '.2f')} seconds")

La réponse semble bonne et la citation est parfaite. Le Llama 3 70B a mis moins de ~4 secondes à être invoqué depuis les endpoints OctoAI.

Exécuter Llama 3 depuis les endpoints Groq LPU

Pour exécuter l’inférence Llama 3 depuis les endpoints Groq :

Allez sur console.groq.com et suivez les instructions.
Obtenez votre jeton d’API d’endpoint Groq et mettez à jour vos variables d’environnement.
Pour Python, pip install groq.
Lisez à propos du modèle Llama 3 8B téléchargé depuis HuggingFace et invoquez-le.

from groq import Groq

LLM_NAME = "llama3-70b-8192"

groq_client = Groq(
   api_key=os.environ.get("GROQ_API_KEY"),
)

start_time = time.time()
response = groq_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_groq_endpoints_time = time.time() - start_time

# Print the response.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_groq_endpoints_time: {format(llama3_groq_endpoints_time, '.2f')} seconds")

La réponse semble légèrement plus concise, et la citation est parfaite. Le Llama 3 20B a pris environ 1 seconde pour être invoqué depuis les points de terminaison Groq LPU, ce qui est l’inférence la plus rapide jusqu’à présent !

Remarque : pour exécuter Mixtral, suivez toutes les mêmes étapes, changez simplement LLM_NAME pour le nom utilisé par chaque plateforme de points de terminaison pour le modèle Mixtral.

Exécuter GPT-4o depuis OpenAI

Pour exécuter la dernière inférence GPT-4o depuis OpenAI :

Obtenez votre jeton API OpenAI et mettez à jour vos variables d’environnement.
Suivez les instructions pour savoir comment appeler le nouveau modèle.
Pour Python, pip install --upgrade openai --quiet.
Lisez des informations sur le nouveau modèle GPT-4o et invoquez-le.

import openai, pprint
from openai import OpenAI

LLM_NAME = "gpt-4o" # "gpt-3.5-turbo"

openai_client = OpenAI(
   # This is the default and can be omitted
   api_key=os.environ.get("OPENAI_API_KEY"),
)

start_time = time.time()
response = openai_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
chatgpt_4o_turbo_time = time.time() - start_time

# Print the question and answer along with grounding sources and citations.
print(f"Question: {SAMPLE_QUESTION}")
for i, choice in enumerate(response.choices, 1):
   message = choice.message.content.replace('\n', '')
   pprint.pprint(f"Answer: {message}")
print(f"chatgpt_4o_turbo_time: {format(chatgpt_4o_turbo_time, '.5f')}")

Le nouveau modèle GPT-4o semble bon et il inclut une citation de source d’ancrage. Il a fallu 2 secondes pour exécuter l’inférence.

Évaluation rapide des réponses avec Ragas

J’explique dans ce blog comment utiliser Ragas, open source, pour évaluer les systèmes RAG. Je n’utilise qu’une seule question-réponse ci-dessous. Une évaluation plus réaliste utiliserait environ 20 questions.

import os, sys
import pandas as pd
import numpy as np
import ragas, datasets
from langchain_community.embeddings import HuggingFaceEmbeddings
from ragas.embeddings import LangchainEmbeddingsWrapper

from ragas.metrics import (
   # context_recall,
   # context_precision,
   # faithfulness,
   answer_relevancy,
   answer_similarity,
   answer_correctness
   )

# Read ground truth answers from file.
eval_df = pd.read_csv(file_path, header=0, skip_blank_lines=True)

# Possible LLM model choices to evaluate:
# openai gpt-4o = 'Custom_RAG_answer'
LLM_TO_EVALUATE = 'Custom_RAG_answer'
# LLM_TO_EVALUATE = 'llama3_ollama_answer'
# LLM_TO_EVALUATE = 'llama3_anyscale_answer'
# LLM_TO_EVALUATE = 'llama3_octoai_answer'
# LLM_TO_EVALUATE = 'llama3_groq_answer'
# LLM_TO_EVALUATE = 'mixtral_8x7b_anyscale_answer'

CONTEXT_TO_EVALUATE='Custom_RAG_context'
eval_metrics=[
    answer_relevancy,
    answer_similarity,
    answer_correctness,]
metrics = ['answer_relevancy', 'answer_similarity', 'answer_correctness']
  
# Change the default llm-as-critic, to save $.
LLM_NAME = "gpt-3.5-turbo"
ragas_llm = ragas.llms.llm_factory(model=LLM_NAME)

# Change the default embeddings to HuggingFace models.
EMB_NAME = "BAAI/bge-large-en-v1.5"
lc_embeddings = HuggingFaceEmbeddings(model_name=EMB_NAME)
ragas_emb = LangchainEmbeddingsWrapper(embeddings=lc_embeddings)

# Modifiez chaque métrique.
for metric in metrics:
   globals()[metric].llm = ragas_llm
   globals()[metric].embeddings = ragas_emb

# Exécutez l’évaluation.
ragas_result, score = _eval_ragas.evaluate_ragas_model(
   eval_df, eval_metrics, LLM_TO_EVALUATE,
   CONTEXT_TO_EVALUATE, EVALUATE_WHAT)

# Affichez les résultats.
print(f"À partir de {eval_df.shape[0]} questions d’évaluation, score moyen = {score}")
display(ragas_result.head())

Vous trouverez ci-dessous un tableau récapitulant les résultats.


Point de terminaison du modèle	Réponse	Latence (secondes)	Coût	Score de réponse Ragas
`Ollama Llama 3`	Selon le contexte et les sources fournis [1, 65535], dans le Hierarchical Navigable Small World Graph (HNSW), il existe deux paramètres principaux : * `M` : Degré maximal des nœuds sur chaque couche du graphe. Il va de 2 à 2048. * `ef` ou `efConstruction` : Ce paramètre spécifie une plage de recherche, qui peut être utilisée lors de la construction de l’index ou de la recherche de cibles. Ces paramètres visent à améliorer les performances et à contrôler le compromis entre le taux de rappel (amélioré en augmentant ef) et le temps de recherche (augmenté avec des valeurs M plus élevées).	`13.74`	`Gratuit`	`0.76`
`Anyscale endpoints Llama 3`	`Selon le contexte, les paramètres pour HNSW sont : * M : Degré maximal du nœud, qui va de 2 à 2048. Ce paramètre limite le degré maximal des nœuds sur chaque couche du graphe. * efConstruction (lors de la création de l’index) : spécifie une plage de recherche lors de la création d’un index. * ef (lors de la recherche de cibles) : spécifie une plage de recherche lors de la recherche de cibles.
Source :`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)`'`	`5.94`	`Playground gratuit`	`0.80`
`Anyscale Mixtral`	`Le paramètre M pour HNSW désigne le degré maximal du nœud, c’est-à-dire le nombre maximal de connexions qu’un nœud peut avoir dans la structure du graphe. Il va de 2 à 2048. De plus, efConstruction et ef sont des paramètres utilisés pour spécifier la plage de recherche lors de la création de l’index et de la recherche de cibles, respectivement.
Sources : 1.`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)` 2. `[`https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)`'`	`3.57`	`Playground gratuit`	`0.79`
`OctoAI Llama 3`	`Selon le contexte fourni, les paramètres pour HNSW (Hierarchical Navigable Small World Graph) sont : * M : Degré maximal du nœud, qui va de 2 à 2048. Ce paramètre limite le degré maximal des nœuds sur chaque couche du graphe. * efConstruction : Un paramètre utilisé lors de la création d’un index pour spécifier une plage de recherche. * ef : Un paramètre utilisé lors de la recherche de cibles pour spécifier une plage de recherche.
Source :`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)` `	`4.43`	`0,15 $ par million de tokens`	`0.73`
`Groq Llama 3`	`Selon le contexte fourni, les paramètres pour HNSW sont : * M : Degré maximal du nœud, qui va de 2 à 2048. * efConstruction : Un paramètre utilisé lors de la création de l’index pour spécifier une plage de recherche. * ef : Un paramètre utilisé lors de la recherche de cibles pour spécifier une plage de recherche.
Source : `[`https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)	`1.21`	`Gratuit
bêta`	`0.79`
`Openai gpt-4o`	Les paramètres pour HNSW sont les suivants :``- M : Degré maximal du nœud, limitant les connexions que chaque nœud peut avoir dans le graphe. La plage est [2, 2048].``- efConstruction : Paramètre utilisé lors de la création de l’index pour spécifier une plage de recherche.``- ef : Paramètre utilisé lors de la recherche de cibles pour spécifier une plage de recherche.``Sources :`https://milvus.io/docs/index.md`	`2.13`	`5 $/M entrée
15 $/M sortie`	`0.803`

Source : code de l’auteur et https://console.anyscale.com/v2/playground, https://console.groq.com/playground?model=llama3-70b-8192, https://octoai.cloud/text?selectedTags=Chat, https://openai.com/api/pricing/.

Conclusion

Aujourd’hui, nous avons de nombreuses options de modèles et de points de terminaison d’inférence parmi lesquelles choisir pour la partie G-Generation du RAG ! Tous les points de terminaison testés dans ce blog présentent une qualité de réponse variable (telle qu’évaluée par un critique GPT), des latences et des coûts à prendre en compte.

Mis à jour le Jul 13, 2026

Christy Bergman
Christy Bergman is a passionate Developer Advocate at Zilliz. She previously worked in distributed computing at Anyscale and as a Specialist AI/ML Solutions Architect at AWS. Christy studied applied math, is a self-taught coder, and has published papers, including one with ACM Recsys. She enjoys hiking and bird watching.

Continuer à lire

My Wife Wanted Dior. I Spent $600 on Claude Code to Vibe-Code a 2M-Line Database Instead.

Write tests, not code reviews. How a test-first workflow with 6 parallel Claude Code sessions turns a 2M-line C++ codebase into a daily shipping pipeline.

DeepSeek Always Busy? Deploy It Locally with Milvus in Just 10 Minutes—No More Waiting!

Learn how to set up DeepSeek-R1 on your local machine using Ollama, AnythingLLM, and Milvus in just 10 minutes. Bypass busy servers and enhance AI responses with custom data.

Zilliz Cloud BYOC Upgrades: Bring Enterprise-Grade Security, Networking Isolation, and More

Discover how Zilliz Cloud BYOC brings enterprise-grade security, networking isolation, and infrastructure automation to vector database deployments in AWS