En este tutorial, implementamos un Ollama Entorno dentro de Google Colab para replicar un flujo de trabajo LLM autohospedado. Comenzamos instalando Ollama directamente en la VM Colab utilizando el instalador oficial de Linux y luego lanzamos el servidor Ollama en segundo plano para exponer la API HTTP en Localhost: 11434. Después de verificar el servicio, extraemos modelos livianos como Qwen2.5: 0.5B-Instructo o LLAMA3.2: 1B, que equilibran las restricciones de recursos con la usabilidad en un entorno de solo CPU. Para interactuar con estos modelos mediante programación, utilizamos el punto final /API /CHAT a través del módulo de solicitudes de Python con transmisión habilitada, lo que permite que la salida a nivel de token se capture de manera incremental. Finalmente, superamos un Gradio-El UI basado en este cliente para que podamos emitir indicaciones, mantener el historial de múltiples vueltas, configurar parámetros como la temperatura y el tamaño de contexto, y la vista de resultados en tiempo real. Mira el Códigos completos aquí.
import os, sys, subprocess, time, json, requests, textwrap
from pathlib import Path
def sh(cmd, check=True):
"""Run a shell command, stream output."""
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
for line in p.stdout:
print(line, end="")
p.wait()
if check and p.returncode != 0:
raise RuntimeError(f"Command failed: {cmd}")
if not Path("/usr/local/bin/ollama").exists() and not Path("/usr/bin/ollama").exists():
print("🔧 Installing Ollama ...")
sh("curl -fsSL https://ollama.com/install.sh | sh")
else:
print("✅ Ollama already installed.")
try:
import gradio
except Exception:
print("🔧 Installing Gradio ...")
sh("pip -q install gradio==4.44.0")Primero verificamos si Ollama ya está instalado en el sistema, y si no, lo instalamos utilizando el script oficial. Al mismo tiempo, nos aseguramos de que Gradio esté disponible importando o instalando la versión requerida cuando falte. De esta manera, preparamos nuestro entorno Colab para ejecutar la interfaz de chat sin problemas. Mira el Códigos completos aquí.
def start_ollama():
try:
requests.get("http://127.0.0.1:11434/api/tags", timeout=1)
print("✅ Ollama server already running.")
return None
except Exception:
pass
print("🚀 Starting Ollama server ...")
proc = subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
for _ in range(60):
time.sleep(1)
try:
r = requests.get("http://127.0.0.1:11434/api/tags", timeout=1)
if r.ok:
print("✅ Ollama server is up.")
break
except Exception:
pass
else:
raise RuntimeError("Ollama did not start in time.")
return proc
server_proc = start_ollama()Comenzamos el ollama servidor En el fondo y sigue revisando su punto final de salud hasta que responda con éxito. Al hacer esto, nos aseguramos de que el servidor esté ejecutado y listo antes de enviar cualquier solicitud de API. Mira el Códigos completos aquí.
MODEL = os.environ.get("OLLAMA_MODEL", "qwen2.5:0.5b-instruct")
print(f"🧠 Using model: {MODEL}")
try:
tags = requests.get("http://127.0.0.1:11434/api/tags", timeout=5).json()
have = any(m.get("name")==MODEL for m in tags.get("models", []))
except Exception:
have = False
if not have:
print(f"⬇️ Pulling model {MODEL} (first time only) ...")
sh(f"ollama pull {MODEL}")Definimos el modelo predeterminado para usar, verifique si ya está disponible en el servidor Ollama, y si no, lo extraemos automáticamente. Esto asegura que el modelo elegido esté listo antes de comenzar a ejecutar cualquier sesión de chat. Mira el Códigos completos aquí.
OLLAMA_URL = "http://127.0.0.1:11434/api/chat"
def ollama_chat_stream(messages, model=MODEL, temperature=0.2, num_ctx=None):
"""Yield streaming text chunks from Ollama /api/chat."""
payload = {
"model": model,
"messages": messages,
"stream": True,
"options": {"temperature": float(temperature)}
}
if num_ctx:
payload["options"]["num_ctx"] = int(num_ctx)
with requests.post(OLLAMA_URL, json=payload, stream=True) as r:
r.raise_for_status()
for line in r.iter_lines():
if not line:
continue
data = json.loads(line.decode("utf-8"))
if "message" in data and "content" in data["message"]:
yield data["message"]["content"]
if data.get("done"):
breakCreamos un cliente de transmisión para el punto final Ollama /API /CHAT, donde enviamos mensajes como cargas útiles JSON y tokens de rendimiento a medida que llegan. Esto nos permite manejar las respuestas de forma incremental, por lo que vemos la salida del modelo en tiempo real en lugar de esperar la finalización completa. Mira el Códigos completos aquí.
def smoke_test():
print("n🧪 Smoke test:")
sys_msg = {"role":"system","content":"You are concise. Use short bullets."}
user_msg = {"role":"user","content":"Give 3 quick tips to sleep better."}
out = []
for chunk in ollama_chat_stream([sys_msg, user_msg], temperature=0.3):
print(chunk, end="")
out.append(chunk)
print("n🧪 Done.n")
try:
smoke_test()
except Exception as e:
print("⚠️ Smoke test skipped:", e)Ejecutamos una prueba de humo rápida enviando un mensaje simple a través de nuestro cliente de transmisión para confirmar que el modelo responde correctamente. Esto nos ayuda a verificar que Ollama esté instalado, el servidor se está ejecutando y el modelo elegido funciona antes de construir la interfaz de usuario de chat completa. Mira el Códigos completos aquí.
import gradio as gr
SYSTEM_PROMPT = "You are a helpful, crisp assistant. Prefer bullets when helpful."
def chat_fn(message, history, temperature, num_ctx):
msgs = [{"role":"system","content":SYSTEM_PROMPT}]
for u, a in history:
if u: msgs.append({"role":"user","content":u})
if a: msgs.append({"role":"assistant","content":a})
msgs.append({"role":"user","content": message})
acc = ""
try:
for part in ollama_chat_stream(msgs, model=MODEL, temperature=temperature, num_ctx=num_ctx or None):
acc += part
yield acc
except Exception as e:
yield f"⚠️ Error: {e}"
with gr.Blocks(title="Ollama Chat (Colab)", fill_height=True) as demo:
gr.Markdown("# 🦙 Ollama Chat (Colab)nSmall local-ish LLM via Ollama + Gradio.n")
with gr.Row():
temp = gr.Slider(0.0, 1.0, value=0.3, step=0.1, label="Temperature")
num_ctx = gr.Slider(512, 8192, value=2048, step=256, label="Context Tokens (num_ctx)")
chat = gr.Chatbot(height=460)
msg = gr.Textbox(label="Your message", placeholder="Ask anything…", lines=3)
clear = gr.Button("Clear")
def user_send(m, h):
m = (m or "").strip()
if not m: return "", h
return "", h + [[m, None]]
def bot_reply(h, temperature, num_ctx):
u = h[-1][0]
stream = chat_fn(u, h[:-1], temperature, int(num_ctx))
acc = ""
for partial in stream:
acc = partial
h[-1][1] = acc
yield h
msg.submit(user_send, [msg, chat], [msg, chat])
.then(bot_reply, [chat, temp, num_ctx], [chat])
clear.click(lambda: None, None, chat)
print("🌐 Launching Gradio ...")
demo.launch(share=True)Integramos Gradio para construir una interfaz de usuario de chat interactiva en la parte superior del servidor Ollama, donde la entrada del usuario y el historial de conversación se convierten en el formato de mensaje correcto y se transmiten como respuestas del modelo. Los controles deslizantes nos permitieron ajustar parámetros como la temperatura y la longitud de contexto, mientras que el cuadro de chat y el botón Bore proporcionan una interfaz simple y en tiempo real para probar diferentes indicaciones.
En conclusión, establecemos una tubería reproducible para ejecutar Ollama en Colab: instalación, inicio del servidor, administración de modelos, acceso a API e integración de interfaz de usuario. El sistema utiliza la API REST de Ollama como la capa de interacción central, proporcionando acceso de transmisión de línea de comandos y de Python, mientras que Gradio maneja la persistencia de la sesión y la representación de chat. Este enfoque conserva el diseño “autohospedado” descrito en la guía original, pero lo adapta para las limitaciones de Colab, donde las imágenes Ollama respaldadas por Docker y GPU no son prácticas. El resultado es un marco compacto pero técnicamente completo que nos permite experimentar con múltiples LLM, ajustar los parámetros de generación dinámicamente y probar la IA conversacional localmente dentro de un entorno de cuaderno.
Mira el Códigos completos aquí. No dude en ver nuestro Página de Github para tutoriales, códigos y cuadernos. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.
Sana Hassan, una pasante de consultoría en MarktechPost y estudiante de doble grado en IIT Madras, le apasiona aplicar tecnología e IA para abordar los desafíos del mundo real. Con un gran interés en resolver problemas prácticos, aporta una nueva perspectiva a la intersección de la IA y las soluciones de la vida real.