Construye un agente de IA desde cero con Python, Ollama y Spotify

Guía paso a paso: de un modelo que solo habla a uno que busca, recuerda y reproduce música. Todo open source.

Hazel Sáenz

Published Jun 10, 2026

Last modified Jul 26, 2026

En este workshop vas a construir un agente de IA que actúa como tu DJ personal. No un chatbot que solo habla de música. Un agente que busca, recuerda, se conecta a Spotify y tiene una interfaz visual.

Vamos a construirlo por capas:

Capa	Qué aprenderás	Conceptos clave
1 - Agente básico	Un modelo que solo habla	`Agent`, `OllamaModel`
2 - Con herramientas	El agente busca en tu biblioteca	`@tool`, tool calling
4 - Memoria	El agente recuerda entre sesiones	`FileSessionManager`
5 - Spotify	Conexión a una API real externa	`BedrockModel`, `spotipy`
6 - Frontend (bono)	Interfaz web con Streamlit	`streamlit`, CSS, UX

Cada capa agrega una capacidad nueva. Puedes parar en cualquier punto y ya habrás aprendido algo funcional.

Prerrequisitos

Antes de empezar, necesitas tener instalado y configurado lo siguiente en tu máquina.

Para macOS

Herramienta	Cómo instalar	Verificar
Python 3.10+	`brew install python@3.12`	`python3 --version`
pip	Viene con Python	`pip3 --version`
Git	`brew install git`	`git --version`
Ollama	`brew install ollama`	`ollama --version`
AWS CLI	`brew install awscli`	`aws --version`

Para Windows

Herramienta	Cómo instalar	Verificar
Python 3.10+	Descarga desde python.org (marca "Add to PATH")	`python --version`
pip	Viene con Python	`pip --version`
Git	Descarga desde git-scm.com	`git --version`
Ollama	Descarga desde ollama.com/download	`ollama --version`
AWS CLI	Descarga desde Amazon CLI	`aws --version`

Nota para Windows: Usa PowerShell o Windows Terminal. Si algo no funciona con python3, prueba con python. El comando puede variar según cómo hayas instalado Python.

Cuentas necesarias

Cuenta de AWS con acceso a Amazon Bedrock habilitado (para la capa 5)
Cuenta de Spotify Premium + app creada en developer.spotify.com/dashboard (para la capa 5). La API de Spotify requiere cuenta Premium para todas las operaciones
Ambas son opcionales si solo quieres hacer las capas 1, 2 y 4 (que corren 100% local)

Configurar AWS CLI (para la capa 5)

Si vas a hacer la capa 5 con Spotify y Bedrock, necesitas tener tus credenciales de AWS configuradas:

1
aws configure

Te pedirá:

Access Key ID
Secret Access Key
Default region: us-east-1
Output format: json

Asegúrate de que tu usuario de IAM tenga permisos para invocar modelos en Amazon Bedrock.

Paso 0: Preparar el entorno

Clonar el repositorio

1
2
git clone https://github.com/hsaenzG/OpenSource-agents-demo.git
cd OpenSource-agents-demo

Crear el entorno virtual de Python

1
2
3
4
5
6
7
# macOS / Linux
python3 -m venv .venv
source .venv/bin/activate

# Windows (PowerShell)
python -m venv .venv
.\.venv\Scripts\Activate.ps1

Instalar dependencias

1
pip install -r requirements.txt

Esto instala:

strands-agents[ollama]: el SDK de agentes con soporte para Ollama
spotipy: cliente de Python para la API de Spotify
python-dotenv: para cargar variables de entorno desde .env
streamlit: para el frontend web
botocore[crt]: para las credenciales de AWS

Instalar y levantar Ollama

Si todavía no descargaste el modelo:

1
ollama pull llama3.1

Verifica que el servidor esté corriendo:

1
ollama serve

Tip: Si instalaste la app de escritorio de Ollama en macOS, el servidor ya corre en segundo plano. No necesitas ejecutar ollama serve manualmente.

Para verificar que todo funciona:

1
curl http://localhost:11434/api/tags

Deberías ver un JSON con el modelo llama3.1 listado.

Capa 1: El agente que solo habla

La primera capa es la más simple: un modelo de lenguaje con un system prompt. Sin herramientas. El agente solo puede responder con lo que "sabe" de su entrenamiento.

¿Qué vamos a entender aquí?

Un agente necesita, como mínimo, tres cosas:

Un modelo (el cerebro)
Un system prompt (la personalidad)
El SDK que conecta ambos (Strands Agents)

El código

Abre el archivo capa1_agente_basico.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from strands import Agent
from strands.models.ollama import OllamaModel
from utils_color import color_callback_handler, print_prompt, print_agent_prefix, print_agent_end

modelo = OllamaModel(
    model_id="llama3.1",
    host="http://localhost:11434",
)

dj = Agent(
     model=modelo,
     callback_handler=color_callback_handler,
     system_prompt="""Eres un DJ y curador musical experto.
     Respondes en español, con onda y buen gusto.
     Recomiendas música basándote en el mood, la ocasión, y los gustos del usuario."""
)

prompt = "¿Cual fue el último exitó de Queen?"
print_prompt(prompt)
print_agent_prefix()
dj(prompt)
print_agent_end()

Ejecutar

1
python capa1_agente_basico.py

¿Qué está pasando aquí?

OllamaModel conecta con el modelo que corre localmente en tu máquina
Agent crea el agente con su personalidad definida en system_prompt
dj(prompt) invoca al agente con tu pregunta

El agente responde, pero inventa. No tiene acceso a datos reales. Si le preguntas por tu biblioteca, no la conoce. Si le preguntas algo fuera de su fecha de corte de entrenamiento, alucina.

La limitación

Prueba preguntar algo como: "¿Qué canciones de jazz tengo en mi biblioteca?"

No puede responder. No tiene herramientas. Solo habla.

Y aquí es donde se pone interesante.

Capa 2: El agente que busca (herramientas)

El concepto más importante de todo el workshop: tool calling.

Un modelo por sí solo no puede ejecutar código. Pero si le dices "tienes esta herramienta disponible", el modelo puede decidir cuándo invocarla. Tú defines la función, el modelo decide cuándo usarla.

¿Qué vamos a aprender aquí?

Cómo crear una herramienta con el decorador @tool
Cómo el modelo decide solo cuándo usarla
La diferencia entre un chatbot y un agente

El código

Abre el archivo capa2_con_tools.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from strands import Agent, tool
from strands.models.ollama import OllamaModel
from utils_color import color_callback_handler, print_prompt, print_agent_prefix, print_agent_end
import json

# Cargar biblioteca local de canciones
with open("data/canciones.json") as f:
    BIBLIOTECA = json.load(f)

@tool
def buscar_canciones(genero: str = "", mood: str = "", artista: str = "") -> str:
    """Busca canciones en la biblioteca musical del usuario.
    
    Args:
        genero: Género musical (ej: rock, jazz, reggaetón, electrónica)
        mood: Estado de ánimo o energía (ej: chill, fiesta, melancólico, energético)
        artista: Nombre del artista o banda
    """
    resultados = BIBLIOTECA
    if genero:
        resultados = [c for c in resultados if genero.lower() in c["genero"].lower()]
    if mood:
        resultados = [c for c in resultados if mood.lower() in c["mood"].lower()]
    if artista:
        resultados = [c for c in resultados if artista.lower() in c["artista"].lower()]
    
    if not resultados:
        return "No encontré canciones con esos criterios en tu biblioteca."
    
    return json.dumps(resultados[:10], ensure_ascii=False, indent=2)

modelo = OllamaModel(model_id="llama3.1", host="http://localhost:11434")

dj = Agent(
    model=modelo,
    system_prompt="""Eres un DJ y curador musical experto.
    Usa la herramienta buscar_canciones para encontrar música en la biblioteca del usuario.
    Siempre basa tus recomendaciones en canciones que el usuario realmente tiene.""",
    tools=[buscar_canciones],
    callback_handler=color_callback_handler,
)

prompt = "Quiero escuchar jazz mientras trabajo"
print_prompt(prompt)
print_agent_prefix()
dj(prompt)
print_agent_end()

Ejecutar

1
python capa2_con_tools.py

¿Qué está pasando aquí?

Fíjate en el decorador @tool. Convierte cualquier función de Python en una herramienta que el modelo puede invocar. El docstring y los type hints le dicen al modelo qué hace la función y qué parámetros acepta.

Cuando le dices "Quiero escuchar jazz mientras trabajo", el modelo:

Razona: "El usuario quiere jazz, debería buscar en su biblioteca"
Invoca: buscar_canciones(genero="jazz")
Recibe: la lista de canciones de jazz de tu canciones.json
Responde: con recomendaciones basadas en datos reales

Ya no inventa. Busca en tu biblioteca real.

Fíjate en la consola

Vas a ver algo como:

1
⚙️  Usando herramienta: buscar_canciones

Eso significa que el modelo decidió por sí solo que necesitaba llamar a la herramienta. Tú no le dijiste "llama a buscar_canciones". Él lo decidió.

Eso es el agent loop: el modelo razona, invoca tools, recibe resultados, y vuelve a razonar hasta tener una respuesta.

Capa 4: El agente que recuerda (memoria)

Hasta ahora, cada vez que ejecutas el script, el agente empieza de cero. No recuerda que te gusta el rock. No recuerda la playlist del viernes pasado.

En esta capa, le damos memoria persistente.

¿Qué vamos a aprender aquí?

Cómo usar FileSessionManager para guardar conversaciones
Cómo el agente usa el historial para personalizar respuestas
Múltiples herramientas trabajando juntas

El código

Abre el archivo capa4_memoria.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
from strands import Agent, tool
from strands.models.ollama import OllamaModel
from strands.session.file_session_manager import FileSessionManager
from utils_color import color_callback_handler, print_prompt, print_agent_prefix, print_agent_end
import json
import os
import shutil

# Cargar biblioteca local de canciones
with open("data/canciones.json") as f:
    BIBLIOTECA = json.load(f)

@tool
def buscar_canciones(genero: str = "", mood: str = "", artista: str = "") -> str:
    """Busca canciones en la biblioteca musical del usuario.
    
    Args:
        genero: Género musical (ej: rock, jazz, reggaetón, electrónica)
        mood: Estado de ánimo o energía (ej: chill, fiesta, melancólico, energético)
        artista: Nombre del artista o banda
    """
    resultados = BIBLIOTECA
    if genero:
        resultados = [c for c in resultados if genero.lower() in c["genero"].lower()]
    if mood:
        resultados = [c for c in resultados if mood.lower() in c["mood"].lower()]
    if artista:
        resultados = [c for c in resultados if artista.lower() in c["artista"].lower()]
    if not resultados:
        return "No encontré canciones con esos criterios en tu biblioteca."
    return json.dumps(resultados[:10], ensure_ascii=False, indent=2)

@tool
def analizar_energia(canciones: list) -> str:
    """Analiza el nivel de energía promedio de una lista de canciones y sugiere el orden ideal.
    
    Args:
        canciones: Lista de nombres de canciones a analizar
    """
    energia_map = {}
    for cancion in BIBLIOTECA:
        energia_map[cancion["titulo"].lower()] = cancion.get("energia", 50)
    
    analisis = []
    for titulo in canciones:
        energia = energia_map.get(titulo.lower(), 50)
        analisis.append({"titulo": titulo, "energia": energia})
    
    analisis.sort(key=lambda x: x["energia"])
    promedio = sum(c["energia"] for c in analisis) / len(analisis) if analisis else 0
    
    return json.dumps({
        "energia_promedio": round(promedio),
        "flow": "ascendente" if analisis[0]["energia"] < analisis[-1]["energia"] else "descendente",
        "orden_sugerido": [c["titulo"] for c in analisis],
    }, ensure_ascii=False)

@tool
def duracion_playlist(canciones: list) -> str:
    """Calcula la duración total de una playlist y sugiere si necesita más canciones.
    
    Args:
        canciones: Lista de nombres de canciones
    """
    duracion_map = {}
    for cancion in BIBLIOTECA:
        duracion_map[cancion["titulo"].lower()] = cancion.get("duracion_min", 3.5)
    
    total = sum(duracion_map.get(t.lower(), 3.5) for t in canciones)
    
    return json.dumps({
        "canciones": len(canciones),
        "duracion_total_min": round(total, 1),
        "duracion_formato": f"{int(total // 60)}h {int(total % 60)}min" if total >= 60 else f"{int(total)}min",
        "sugerencia": "Playlist corta, podrías agregar más canciones" if total < 30 else "Buena duración"
    }, ensure_ascii=False)

modelo = OllamaModel(model_id="llama3.1", host="http://localhost:11434")

def crear_session_manager(session_id: str, storage_dir: str = "./sesiones") -> FileSessionManager:
    """Crea un FileSessionManager que funciona tanto si la sesión es nueva como si ya existe."""
    session_path = os.path.join(storage_dir, f"session_{session_id}")
    session_file = os.path.join(session_path, "session.json")
    
    if os.path.exists(session_path) and not os.path.exists(session_file):
        shutil.rmtree(session_path)
    
    return FileSessionManager(session_id=session_id, storage_dir=storage_dir)

session_manager = crear_session_manager("usuario-1")

dj = Agent(
    model=modelo,
    system_prompt="""Eres un DJ y curador musical experto.
    Recuerdas los gustos del usuario entre conversaciones.
    Si el usuario ya te dijo qué le gusta, úsalo para personalizar tus playlists.
    Usa tus herramientas para buscar en la biblioteca real del usuario.""",
    tools=[buscar_canciones, analizar_energia, duracion_playlist],
    session_manager=session_manager,
    callback_handler=color_callback_handler,
)

# Primera conversación
prompt1 = "Me encanta el indie rock y el rock en español y rock clasico."
print_prompt(prompt1)
print_agent_prefix()
dj(prompt1)
print_agent_end()

print()

# Segunda conversación — el agente debería recordar los gustos
prompt2 = "Armame algo para el viernes"
print_prompt(prompt2)
print_agent_prefix()
dj(prompt2)
print_agent_end()

Ejecutar

1
python capa4_memoria.py

¿Qué está pasando aquí?

La línea clave es:

1
session_manager = crear_session_manager("usuario-1")

FileSessionManager guarda las conversaciones en una carpeta ./sesiones/. Cada vez que el agente interactúa contigo, el historial se persiste a disco.

Fíjate en las dos conversaciones:

Primero le dices "Me encanta el indie rock y el rock en español"
Luego le dices "Armame algo para el viernes"

En la segunda conversación, el agente recuerda que te gusta el rock y busca canciones que coincidan con tus gustos sin que se lo vuelvas a decir.

También nota: múltiples herramientas

Ahora el agente tiene tres tools:

buscar_canciones: busca por género, mood o artista
analizar_energia : analiza el flow de energía de una lista
duracion_playlist: calcula si la playlist es muy corta o muy larga

El modelo decide cuáles usar y en qué orden. Para una playlist del viernes, probablemente hará algo como:

Buscar canciones de rock (porque recuerda tus gustos)
Analizar la energía para que el flow suba gradualmente
Verificar que la duración sea razonable

Todo eso lo decide el modelo. Tú solo definiste las herramientas.

Capa 5: Conexión con Spotify (API externa)

Hasta ahora todo corre local con Ollama. En esta capa damos un salto: nos conectamos a la API de Spotify para buscar canciones reales, crear playlists en tu cuenta, y reproducir música en tu dispositivo.

Además, cambiamos de modelo: pasamos de Ollama (local) a Amazon Bedrock (cloud) con el modelo Nova Pro. ¿Por qué? Porque las capas avanzadas requieren un modelo más potente para manejar múltiples herramientas con instrucciones complejas.

¿Qué vamos a aprender aquí?

Cómo conectar un agente a una API externa real
Cómo usar Amazon Bedrock como proveedor de modelos
Cómo manejar autenticación OAuth (Spotify)
Herramientas que hacen acciones reales (reproducir música, crear playlists)

Configurar Spotify

Antes de ejecutar esta capa, necesitas crear una app en Spotify:

Ve a developer.spotify.com/dashboard
Click en Create App
Nombre: lo que quieras (ej: "DJ Agent Workshop")
Redirect URI: 127.0.0.1:8000/callback
Marca Web API
Guarda el Client ID y Client Secret

Crea un archivo .env en la raíz del proyecto:

1
2
SPOTIFY_CLIENT_ID=tu-client-id-aqui
SPOTIFY_CLIENT_SECRET=tu-client-secret-aqui

Nota: La primera vez que ejecutes el script, se abrirá el navegador para autorizar la app. Después, el token se cachea automáticamente en un archivo .cache.

El código

El archivo capa5_spotify.py es más largo porque tiene muchas herramientas. Veamos las partes importantes.

Conexión con Spotify:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from dotenv import load_dotenv
import spotipy
from spotipy.oauth2 import SpotifyOAuth

load_dotenv()

sp = spotipy.Spotify(
    auth_manager=SpotifyOAuth(
        client_id=os.getenv("SPOTIFY_CLIENT_ID"),
        client_secret=os.getenv("SPOTIFY_CLIENT_SECRET"),
        redirect_uri="http://127.0.0.1:8000/callback",
        scope="playlist-modify-public,playlist-modify-private,user-library-read,user-read-recently-played,user-top-read,user-modify-playback-state,user-read-playback-state",
    ),
)

Cambio de modelo (de Ollama a Bedrock):

1
2
3
from strands.models import BedrockModel

modelo = BedrockModel(model_id="us.amazon.nova-pro-v1:0", region_name="us-east-1")

Fíjate: cambiar de modelo local a cloud es una línea. El resto del código (tools, agent loop, prompts) no cambia. Esa es una ventaja de usar un SDK que abstrae el proveedor.

Herramientas de Spotify:

1
2
3
4
5
6
7
8
9
10
11
12
@tool
def buscar_en_spotify(query: str, limite: int = 10) -> str:
    """Busca canciones en Spotify por nombre, artista o género.
    SIEMPRE usa esta herramienta cuando el usuario pregunte por canciones.
    
    Args:
        query: Texto de búsqueda (ej: "Shakira", "rock alternativo")
        limite: Número máximo de resultados (default: 10)
    """
    resultados = sp.search(q=str(query), type="track", limit=limite)
    tracks = resultados["tracks"]["items"]
    # ... formatear y retornar

1
2
3
4
5
6
7
8
9
10
@tool
def reproducir_cancion(nombre_cancion: str, artista: str = "") -> str:
    """Reproduce una canción en el dispositivo activo de Spotify del usuario.
    
    Args:
        nombre_cancion: Nombre de la canción a reproducir
        artista: Nombre del artista (opcional)
    """
    # Busca la canción, encuentra tu dispositivo activo, y reproduce
    # ...

1
2
3
4
5
6
7
8
9
10
11
@tool
def crear_playlist_en_spotify(nombre: str, descripcion: str, canciones_uris: list) -> str:
    """Crea una playlist en la cuenta de Spotify del usuario.
    
    Args:
        nombre: Nombre de la playlist
        descripcion: Descripción breve
        canciones_uris: Lista de URIs de Spotify o nombres de canciones
    """
    # Crea la playlist y agrega las canciones
    # ...

Las herramientas disponibles en esta capa

Herramienta	Qué hace
`buscar_en_spotify`	Busca canciones reales en el catálogo de Spotify
`buscar_canciones`	Busca en tu biblioteca local (fallback)
`crear_playlist_en_spotify`	Crea una playlist en tu cuenta
`reproducir_cancion`	Reproduce una canción en tu dispositivo activo
`reproducir_playlist`	Reproduce una playlist completa
`mis_top_artistas`	Obtiene tus artistas más escuchados
`mis_top_canciones`	Obtiene tus canciones más escuchadas
`obtener_recomendaciones_spotify`	Pide recomendaciones basadas en semillas

Ejecutar

1
python capa5_spotify.py

La primera vez te pedirá autorización en el navegador. Después, puedes hablar con el agente de forma interactiva:

1
2
3
4
5
6
7
8
9
10
11
12
🎧 DJ Personal con Spotify
==================================================
Escribe tu mensaje (o 'salir' para terminar)

🎵 Tú: ponme Bohemian Rhapsody
🤖 DJ: ▶️ Reproduciendo: Bohemian Rhapsody — Queen

🎵 Tú: armame una playlist de rock para el gym
🤖 DJ: (busca canciones energéticas, crea la playlist en tu cuenta)

🎵 Tú: salir
👋 ¡Nos vemos! Que suene buena música.

Lo importante de esta capa

El agente pasó de "saber cosas" a "hacer cosas". Ya no solo recomienda. Ejecuta. Reproduce música. Crea playlists reales en tu cuenta. Busca en un catálogo de millones de canciones.

Y todo con el mismo patrón: tú defines @tool, el modelo decide cuándo y cómo usarlas.

Nota: La API de Spotify requiere una cuenta Premium para todas las operaciones (buscar, crear playlists, reproducir, ver top artistas). Si no tienes Premium, no podrás usar esta capa con Spotify.

Sin Spotify: Si no configuraste Spotify o no tienes cuenta Premium, el agente sigue funcionando con la biblioteca local como fallback. Verás un aviso ⚠️ Spotify no disponible al iniciar.

Capa 6 (Bono): Frontend con Streamlit

Hasta aquí todo ha sido en la terminal. Para la capa final, vamos a darle una cara visual al agente con Streamlit: una interfaz web con tema oscuro, estilo dev + rock, y un widget de "Now Playing" que muestra en tiempo real lo que está sonando.

¿Qué vamos a ver aquí?

Una interfaz de chat web conectada al agente
Widget de "Now Playing" con carátula del álbum
Quick prompts para arrancar rápido
Status del sistema (agente, Spotify, biblioteca)

Ejecutar

1
streamlit run app.py

¿Qué incluye el frontend?

El archivo app.py es largo (1000+ líneas), pero la estructura es simple:

CSS custom: tema oscuro con gradientes negro/púrpura y acentos neón
Sidebar: status del sistema, Now Playing widget, stats de la biblioteca, quick prompts
Chat principal: interfaz conversacional con el agente DJ
Integración con el agente: el mismo agente de la capa 5 pero con callback_handler adaptado para web

Las funciones principales

Inicialización del agente (igual que capa 5, pero sin output a consola):

1
2
3
4
5
6
7
8
agent = Agent(
    model=BedrockModel(model_id="us.amazon.nova-pro-v1:0", region_name="us-east-1"),
    system_prompt="...",
    tools=[buscar_canciones, buscar_en_spotify, reproducir_cancion, 
           crear_playlist_en_spotify, mis_top_artistas, mis_top_canciones,
           analizar_energia, duracion_playlist],
    callback_handler=None,  # Sin output a terminal
)

Widget Now Playing (consulta Spotify cada 5 segundos):

1
2
3
4
5
6
@st.fragment(run_every=5)
def now_playing_widget():
    playback = sp.current_playback()
    if playback and playback.get("item"):
        # Muestra: carátula, canción, artista, barra de progreso
        ...

Manejo del chat:

1
2
3
if prompt := st.chat_input("Pedí tu playlist..."):
    response = st.session_state["agent"](prompt)
    # Muestra la respuesta con formato

Requisitos para el frontend

Todo lo de la capa 5 (AWS CLI, Spotify configurado)
Streamlit ya está en el requirements.txt
El puerto 8501 disponible

Quick prompts incluidos

La sidebar tiene botones rápidos:

🎸 Rock para programar
🎉 Playlist de fiesta 1h
🌙 Algo chill para la noche
😢 Estoy melancólico
⚡ Máxima energía

Solo haz click y el agente se pone a trabajar.

Resumen: lo que construiste

Si llegaste hasta aquí, construiste un agente de IA funcional desde ceron no es un ejemplo teórico es un agente que busca, recuerda, se conecta a Spotify, y tiene una interfaz web.
Pasaste de un chatbot que solo habla a un agente que busca, recuerda, se conecta a APIs externas, y tiene una interfaz visual.

Capa 1 - Conectaste un modelo local con Strands Agents
Capa 2 - Le diste herramientas para buscar en datos reales
Capa 4 - Le diste memoria persistente entre conversaciones
Capa 5 - Lo conectaste a Spotify y Amazon Bedrock
Capa 6 - Le pusiste una interfaz web profesional

Pasaste de un chatbot que solo habla a un agente que busca, recuerda, se conecta a APIs externas, y tiene una interfaz visual.

Y todo con el mismo patrón:

1
2
3
4
5
6
7
8
@tool
def mi_herramienta(parametro: str) -> str:
    """Descripción que el modelo lee para decidir cuándo usarla."""
    # tu lógica aquí
    return resultado

agente = Agent(model=modelo, tools=[mi_herramienta])
agente("haz algo")

Ahora la pregunta es: ¿qué vas a construir con esto? Un agente que consulta tu calendario, uno que revisa tus PRs, uno que gestiona tickets de soporte. El patrón es el mismo. Solo cambian las herramientas. Bienvenido al mundo de los agentes.

Recursos

¿Te resultó útil esta guía? Compártela con tu equipo o déjame saber en los comentarios qué parte te costó más o qué te gustaría que profundice. Y si ya construiste tu propio agente DJ con variaciones, me encantaría ver qué hiciste.

# agents # strands-agents # fundamentals # ai # python

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

Construye un agente de IA desde cero con Python, Ollama y Spotify

Hazel Sáenz

Prerrequisitos

Para macOS

Para Windows

Cuentas necesarias

Configurar AWS CLI (para la capa 5)

Paso 0: Preparar el entorno

Clonar el repositorio

Crear el entorno virtual de Python

Instalar dependencias

Instalar y levantar Ollama

Capa 1: El agente que solo habla

¿Qué vamos a entender aquí?

El código

Ejecutar

¿Qué está pasando aquí?

La limitación

Capa 2: El agente que busca (herramientas)

¿Qué vamos a aprender aquí?

El código

Ejecutar

¿Qué está pasando aquí?

Fíjate en la consola

Capa 4: El agente que recuerda (memoria)

¿Qué vamos a aprender aquí?

El código

Ejecutar

¿Qué está pasando aquí?

También nota: múltiples herramientas

Capa 5: Conexión con Spotify (API externa)

¿Qué vamos a aprender aquí?

Configurar Spotify

El código

Las herramientas disponibles en esta capa

Ejecutar

Lo importante de esta capa

Capa 6 (Bono): Frontend con Streamlit

¿Qué vamos a ver aquí?

Ejecutar

¿Qué incluye el frontend?

Las funciones principales

Requisitos para el frontend

Quick prompts incluidos

Resumen: lo que construiste

Recursos