Blog
Ejecutando Llama 3, Mixtral y GPT-4o

Ejecutando Llama 3, Mixtral y GPT-4o

May 15, 20248 min read

¡Hay muchísimas formas diferentes de ejecutar la parte G-Generation de RAG! Hoy mostraré algunas formas de ejecutar algunos de los contendientes más populares en este espacio: Llama 3 de Meta, Mixtral de Mistral y el recientemente anunciado GPT-4o de OpenAI.

Como podemos ver en el LMSYS Leaderboard a continuación, la brecha (en azul claro) entre los modelos de código cerrado y los modelos de código abierto acaba de ampliarse esta semana con el nuevo anuncio de OpenAI.

código cerrado vs abierto

Fuente de la imagen: https://twitter.com/maximelabonne basada en https://chat.lmsys.org/?leaderboard.

Esquema de este blog:

Las formas más rápidas de ejecutar Llama 3 o Mixtral de código abierto
- Localmente con Ollama
- Endpoints de Anyscale
- Endpoint de OctoAI
- Endpoint de Groq
Ejecutar el gpt-4o más reciente de OpenAI
Evaluar respuestas: GPT-4o, Llama 3, Mixtral

¡Comencemos!

Ejecutar Llama 3 localmente usando Ollama

Primero, ejecuta RAG de la forma habitual, hasta el último paso, donde generas la respuesta, la parte G de RAG. Tenemos muchos tutoriales para empezar con RAG, incluido este en Python.

Para ejecutar Llama 3 localmente usando Ollama.

Sigue las instrucciones para instalar ollama y descargar un modelo.
Esa página dice que ollama run llama3 descargará por defecto el modelo "instruct" más reciente, que está ajustado para casos de uso de chat/diálogo Y cabe en tu computadora. Ejecuta ese comando.
Para Python, pip install ollama.
En tu código Python de RAG, define un Prompt y una Question, e invoca la llamada a la API a tu modelo Llama 3 instalado localmente.

En mi caso, tengo una laptop M2 de 16 GB, así que el modelo Ollama descargado es la versión compilada en gguf con la cuantización más alta de Llama3-8B. Es decir, ¡ahora hay una versión muy pequeña de Llama 3 instalada en mi laptop!

# 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 respuesta se ve bastante bien; veo tres parámetros, pero solo la cita parece distorsionada. El modelo local tardó 13 segundos en ejecutar la inferencia en mi laptop, pero el costo fue gratis.

Ejecutar Llama 3 desde endpoints de Anyscale

Para ejecutar inferencia de Llama 3 desde endpoints de Anyscale:

Sigue las instrucciones en la página de github de Anyscale endpoints para instalar la línea de comandos y luego instalar el plugin.
Obtén tu token de API del endpoint de Anysclae y actualiza tus variables de entorno.
Para Python, pip install openai.
Lee sobre el modelo Llama 3 descargado de HuggingFace e invócalo usando la API de OpenAI. Usé el Llama 3 predeterminado en Anyscale playground, que era un modelo 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 respuesta se ve bien, incluida una cita perfecta. El Llama 3 70B de HuggingFace tardó ~6 segundos en invocarse desde los endpoints de Anyscale.

Ejecutar Llama 3 desde los endpoints de OctoAI

Para ejecutar la inferencia de Llama 3 desde los endpoints de OctoAI:

Ve a https://octoai.cloud/text, elige el modelo Llama 3 8B, haz clic en el enlace del modelo y verás código de ejemplo.
Obtén tu token de API del endpoint de OctoAI y actualiza tus variables de entorno.
Para Python, pip install octoai.
Lee sobre el modelo Llama 3 8B descargado de Meta e invócalo.


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 respuesta se ve bien y la cita es perfecta. El Llama 3 70B tardó menos de ~4 segundos en invocarse desde los endpoints de OctoAI.

Ejecutar Llama 3 desde los endpoints Groq LPU

Para ejecutar la inferencia de Llama 3 desde los endpoints de Groq:

Ve a console.groq.com y sigue las instrucciones.
Obtén tu token de API del endpoint de Groq y actualiza tus variables de entorno.
Para Python, pip install groq.
Lee sobre el modelo Llama 3 8B descargado de HuggingFace e invócalo.

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

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

La respuesta parece un poco más concisa, y la cita es perfecta. Llama 3 20B tardó ~1 segundo en invocarse desde los endpoints de Groq LPU, ¡que es la inferencia más rápida hasta ahora!

Nota: para ejecutar Mixtral, sigue todos los mismos pasos, solo cambia LLM_NAME al nombre utilizado por cada plataforma de endpoints para el modelo Mixtral.

Ejecutar GPT-4o desde OpenAI

Para ejecutar la inferencia más reciente de GPT-4o desde OpenAI:

Obtén tu token de API de OpenAI y actualiza tus variables de entorno.
Sigue las instrucciones sobre cómo llamar al nuevo modelo.
Para Python, pip install --upgrade openai --quiet.
Lee sobre el nuevo modelo GPT-4o e invócalo.

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')}")

El nuevo modelo GPT-4o se ve bien e incluye una cita de fuente de fundamentación. Tardó 2 segundos en ejecutar la inferencia.

Evaluación rápida de respuestas usando Ragas

Explico en este blog cómo usar Ragas de código abierto para evaluar sistemas RAG. Solo estoy usando una pregunta y respuesta a continuación. Una evaluación más realista usaría ~20 preguntas.

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)

# Cambia cada métrica.
for metric in metrics:
   globals()[metric].llm = ragas_llm
   globals()[metric].embeddings = ragas_emb

# Ejecuta la evaluación.
ragas_result, score = _eval_ragas.evaluate_ragas_model(
   eval_df, eval_metrics, LLM_TO_EVALUATE,
   CONTEXT_TO_EVALUATE, EVALUATE_WHAT)

# Muestra los resultados.
print(f"Using {eval_df.shape[0]} eval questions, Mean Score = {score}")
display(ragas_result.head())

A continuación se muestra una tabla que resume los resultados.


Endpoint del modelo	Respuesta	Latencia (segundos)	Costo	Puntuación de respuesta de Ragas
`Ollama Llama 3`	Según el contexto y las fuentes proporcionadas [1, 65535], en Hierarchical Navigable Small World Graph (HNSW), hay dos parámetros principales: * `M`: Grado máximo de los nodos en cada capa del grafo. Varía de 2 a 2048. * `ef` o `efConstruction`: Este parámetro especifica un rango de búsqueda, que puede usarse durante la construcción del índice o la búsqueda de objetivos. Estos parámetros tienen como objetivo mejorar el rendimiento y controlar el equilibrio entre la tasa de recuperación (mejorada al aumentar ef) y el tiempo de búsqueda (aumentado con valores de M más grandes).	`13.74`	`Gratis`	`0.76`
`Anyscale endpoints Llama 3`	`Según el contexto, los parámetros para HNSW son: * M: Grado máximo del nodo, que varía de 2 a 2048. Este parámetro limita el grado máximo de los nodos en cada capa del grafo. * efConstruction (al construir el índice): especifica un rango de búsqueda al construir un índice. * ef (al buscar objetivos): especifica un rango de búsqueda al buscar objetivos.
Fuente:`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)`'`	`5.94`	`Playground gratis`	`0.80`
`Anyscale Mixtral`	`El parámetro M para HNSW se refiere al grado máximo del nodo, que es el número máximo de conexiones que un nodo puede tener en la estructura del grafo. Varía de 2 a 2048. Además, efConstruction y ef son parámetros usados para especificar el rango de búsqueda durante la construcción del índice y la búsqueda de objetivos, respectivamente.
Fuentes: 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 gratis`	`0.79`
`OctoAI Llama 3`	`Según el contexto proporcionado, los parámetros para HNSW (Hierarchical Navigable Small World Graph) son: * M: Grado máximo del nodo, que varía de 2 a 2048. Este parámetro limita el grado máximo de los nodos en cada capa del grafo. * efConstruction: Un parámetro usado al construir un índice para especificar un rango de búsqueda. * ef: Un parámetro usado al buscar objetivos para especificar un rango de búsqueda.
Fuente:`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)` `	`4.43`	`$0.15 por millón de tokens`	`0.73`
`Groq Llama 3`	`Según el contexto proporcionado, los parámetros para HNSW son: * M: Grado máximo del nodo, que varía de 2 a 2048. * efConstruction: Un parámetro usado al construir el índice para especificar un rango de búsqueda. * ef: Un parámetro usado al buscar objetivos para especificar un rango de búsqueda.
Fuente: `[`https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)	`1.21`	`Gratis
beta`	`0.79`
`Openai gpt-4o`	Los parámetros para HNSW son los siguientes:``- M: Grado máximo del nodo, que limita las conexiones que cada nodo puede tener en el grafo. El rango es [2, 2048].``- efConstruction: Parámetro usado durante la construcción del índice para especificar un rango de búsqueda.``- ef: Parámetro usado al buscar objetivos para especificar un rango de búsqueda.``Fuentes:`https://milvus.io/docs/index.md`	`2.13`	`$5/M entrada
$15/M salida`	`0.803`

Fuente: código del autor y 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/.

Conclusión

¡Hoy tenemos muchas opciones de modelos y endpoints de inferencia para elegir para la parte de generación G de RAG! Todos los endpoints probados en este blog tienen una calidad de respuesta variable (según la calificación de un crítico GPT), latencias y costos que considerar.

Actualizado el Jul 28, 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.

Sigue leyendo

Migrating Self-Managed Milvus to Zilliz Cloud for >99% Latency Reduction

Step-by-step guide to migrating 50M vectors from self-managed Milvus to Zilliz Cloud using milvus-backup. Achieve >99% query latency reduction with zero data loss.

From Vector Database to Vector Lakebase

Zilliz offers a fully managed Vector Lakebase powered by Milvus, unifying real-time vector search, lake-scale discovery, and Al data operations.

DeepSeek-OCR Explained: Optical Compression for Scalable Long-Context and RAG Systems

Discover how DeepSeek-OCR uses visual tokens and Contexts Optical Compression to boost long-context LLM efficiency and reshape RAG performance.