Crear tu propio asistente virtual con inteligencia artificial ya no es una tarea reservada a grandes empresas. Gracias a herramientas como Python y las APIs de ChatGPT, hoy es posible construir un asistente funcional, personalizado y conectado a internet con solo unos pocos bloques de código. Esta guía te muestra cómo hacerlo paso a paso, sin necesidad de arquitecturas complejas ni conocimientos avanzados de machine learning.
Vamos a crear un asistente que pueda mantener una conversación, responder preguntas, realizar tareas simples y conectarse a servicios externos si lo deseas. A lo largo de esta guía aprenderás a:
- Configurar tu entorno de desarrollo.
- Utilizar la API de OpenAI con Python.
- Diseñar un bucle conversacional básico.
- Añadir funcionalidades adicionales.
El objetivo es que termines con un asistente completamente funcional y extensible. Vamos allá.
Paso 1: Instalación del entorno y dependencias
Para comenzar, asegúrate de tener Python 3.8 o superior instalado en tu sistema. Puedes comprobarlo ejecutando:
python –version
Es recomendable crear un entorno virtual para aislar las dependencias del proyecto. Abre una terminal, crea y activa el entorno:
python -m venv asistente-env
source asistente-env/bin/activate # En Linux o macOS
En Windows usa:
asistente-envScriptsactivate
A continuación, instala las librerías necesarias:
pip install openai python-dotenv
Por último, necesitarás una clave de API de OpenAI para interactuar con ChatGPT. Crea un archivo .env en la raíz del proyecto y guarda allí tu clave:
OPENAI_API_KEY=tu_clave_aqui
Paso 2: Preparar el entorno de trabajo
Para comenzar a desarrollar tu asistente virtual, necesitas un entorno limpio y controlado. En este paso vamos a crear una carpeta de proyecto, activar un entorno virtual de Python, instalar las bibliotecas necesarias y añadir un archivo .env para gestionar tu clave de API de forma segura.
Primero, crea la carpeta del proyecto y activa un entorno virtual:
mkdir asistente-chatgpt
cd asistente-chatgpt
python -m venv venv
source venv/bin/activate # En Windows: venvScriptsactivate
A continuación, instala las dependencias principales (openai para acceder a la API y python-dotenv para manejar configuraciones):
pip install openai python-dotenv
Después, crea el archivo .env en la raíz del proyecto y añade tu clave de OpenAI (puedes obtenerla en https://platform.openai.com/api-keys:
OPENAI_API_KEY=tu_clave_aqui
Por último, recuerda excluir el archivo .env del repositorio si usas Git:
echo «.env» >> .gitignore
Paso 3: Crear el archivo base y cargar la clave de API
Con el entorno preparado y la clave de OpenAI almacenada de forma segura, el siguiente paso es construir la estructura base del asistente. Empezaremos creando el archivo principal de ejecución y escribiendo el código necesario para conectarnos con la API de ChatGPT.
- Crea un archivo llamado asistente.py en la raíz del proyecto.
- Importa las bibliotecas necesarias: openai, os y dotenv.
- Carga la clave desde el archivo .env para inicializar la API.
import os
import openai
from dotenv import load_dotenv
Cargar las variables de entorno
load_dotenv()
openai.api_key = os.getenv(«OPENAI_API_KEY»)
Paso 4: Crear la función principal del asistente
Ahora vamos a crear la función que se encargará de enviar el mensaje del usuario a la API de ChatGPT y devolver la respuesta. Esta será la base del funcionamiento del asistente virtual.
- Define una función llamada consultar_chatgpt(mensaje) que reciba un mensaje como parámetro.
- Utiliza el modelo gpt-3.5-turbo y configura la estructura del mensaje como una conversación.
- Devuelve la respuesta generada por la IA como texto plano para mostrarla al usuario.
Este enfoque básico permite tener ya una interacción funcional con el modelo. Más adelante añadiremos mejoras como control de errores y gestión de contexto.
def consultar_chatgpt(mensaje):
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=[
{«role»: «user», «content»: mensaje}
]
)
return respuesta[«choices»][0][«message»][«content»]
Paso 5: Ejecutar el asistente en bucle desde la terminal
Una vez definida la función principal, podemos crear un pequeño bucle que permita al usuario interactuar con el asistente desde la línea de comandos. Esto convierte tu script en una herramienta funcional, lista para probar desde consola.
- Añade un bloque if name == «main» para ejecutar el asistente cuando se llame el script directamente.
- Dentro, crea un bucle while que reciba la entrada del usuario, llame a la función consultar_chatgpt() y muestre la respuesta.
- Permite salir del programa escribiendo «salir», «exit» o «quit».
Este modo conversacional es la forma más sencilla de empezar a usar tu asistente. Más adelante podrás ampliar esta lógica para integrarla en interfaces gráficas o web.
if name == «main«:
print(«Escribe tu mensaje o ‘salir’ para terminar.»)
while True:
entrada = input(«Tú: «)
if entrada.lower() in [«salir», «exit», «quit»]:
break
salida = consultar_chatgpt(entrada)
print(«Asistente:», salida)
Paso 6: Personalizar el comportamiento del asistente
Puedes modificar la personalidad y el rol del asistente utilizando un mensaje de tipo system, que se envía al modelo antes de iniciar la conversación. Esto influye en cómo responde, su tono y su especialización.
- Define una lista mensajes que incluya un mensaje inicial del tipo «system».
- A partir de ahí, cada mensaje del usuario se añade con el rol «user» y cada respuesta del modelo se almacena con el rol «assistant».
- Esta estructura permite mantener un historial conversacional y que el asistente recuerde lo que se ha dicho antes durante la sesión.
Por ejemplo, puedes hacer que el asistente actúe como un tutor especializado, un guía turístico o un agente de soporte técnico, según tus necesidades.
mensajes = [
{«role»: «system», «content»: «Eres un asistente útil especializado en Python. Responde de forma clara y concisa.»}
]
def consultar_chatgpt(mensaje):
try:
mensajes.append({«role»: «user», «content»: mensaje})
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=mensajes
)
contenido = respuesta[«choices»][0][«message»][«content»]
mensajes.append({«role»: «assistant», «content»: contenido})
return contenido.strip()
except Exception as e:
return f»Ocurrió un error: {str(e)}»
Paso 7: Añadir entrada de voz para interactuar por micrófono
Para que la interacción con tu asistente sea más natural, puedes permitir que el usuario hable en lugar de escribir. En este paso vamos a integrar reconocimiento de voz en tiempo real usando la biblioteca SpeechRecognition.
Este módulo permite capturar audio desde el micrófono y transcribirlo a texto con servicios como la API de Google Speech, que es gratuita y no requiere clave para usos básicos.
Antes de empezar, instala las siguientes dependencias desde la terminal:
pip install SpeechRecognition pyaudio
Luego, crea una función reconocer_voz() que escuche desde el micrófono y devuelva el texto reconocido. Podrás usar esta función como sustituto del input() en tu asistente.
import speech_recognition as sr
def reconocer_voz():
r = sr.Recognizer()
with sr.Microphone() as source:
print(«Habla ahora…»)
audio = r.listen(source)
try:
texto = r.recognize_google(audio, language=»es-ES»)
print(«Has dicho:», texto)
return texto
except sr.UnknownValueError:
print(«No se entendió el audio»)
return None
except sr.RequestError as e:
print(«Error al conectar con el servicio de reconocimiento:», e)
return None
Paso 7: Añadir entrada de voz para interactuar por micrófono
Para que la interacción con tu asistente sea más natural, puedes permitir que el usuario hable en lugar de escribir. En este paso vamos a integrar reconocimiento de voz en tiempo real usando la biblioteca SpeechRecognition.
Este módulo permite capturar audio desde el micrófono y transcribirlo a texto con servicios como la API de Google Speech, que es gratuita y no requiere clave para usos básicos.
Antes de empezar, instala las siguientes dependencias desde la terminal:
pip install SpeechRecognition pyaudio
Luego, crea una función reconocer_voz() que escuche desde el micrófono y devuelva el texto reconocido. Podrás usar esta función como sustituto del input() en tu asistente.
import speech_recognition as sr
def reconocer_voz():
r = sr.Recognizer()
with sr.Microphone() as source:
print(«Habla ahora…»)
audio = r.listen(source)
try:
texto = r.recognize_google(audio, language=»es-ES»)
print(«Has dicho:», texto)
return texto
except sr.UnknownValueError:
print(«No se entendió el audio»)
return None
except sr.RequestError as e:
print(«Error al conectar con el servicio de reconocimiento:», e)
return None
Paso 8: Guardar el historial de conversación en un archivo
Para mejorar la experiencia del usuario y permitir seguimiento de las conversaciones, es útil guardar cada interacción en un archivo local. Así podrás revisar después lo que el usuario preguntó y cómo respondió el asistente.
Vamos a crear dos funciones: una para guardar cada mensaje en un archivo .txt y otra para recuperar el historial al inicio del programa, si lo deseas.
Primero definimos la función guardar_en_historial() para registrar cada mensaje en un archivo de texto:
def guardar_en_historial(usuario, asistente, archivo=’chat_log.txt’):
with open(archivo, ‘a’, encoding=’utf-8′) as f:
f.write(f’Usuario: {usuario}n’)
f.write(f’Asistente: {asistente}nn’)
Y a continuación, cargar_historial() que permite leer ese historial desde disco y usarlo si se quiere para continuar la conversación:
def cargar_historial(archivo=’chat_log.txt’):
try:
with open(archivo, ‘r’, encoding=’utf-8′) as f:
return f.read()
except FileNotFoundError:
return «»
Después, modifica ligeramente el bucle principal del asistente para que llame a estas funciones tras cada intercambio.
if name == «main«:
historial = cargar_historial()
print(«Escribe tu mensaje o ‘salir’ para terminar.»)
while True:
entrada = input(«Tú: «)
if entrada.lower() in [«salir», «exit», «quit»]:
break
salida = consultar_chatgpt(entrada)
print(«Asistente:», salida)
guardar_en_historial(entrada, salida)
Paso 9: Añadir instrucciones al sistema para personalizar el comportamiento
El modelo de ChatGPT permite definir un mensaje de sistema inicial para condicionar el comportamiento del asistente durante toda la sesión. Este mensaje se envía de forma oculta al modelo y sirve como directriz: puedes usarlo para darle una personalidad concreta, limitar su ámbito de respuesta o ajustar su estilo.
Vamos a modificar nuestro código para incluir un mensaje de sistema que indique, por ejemplo, que el asistente es experto en Python y debe responder de forma clara y concisa. Para ello, cambiaremos la forma en que se construyen los mensajes enviados al modelo.
Primero, crea una lista inicial de mensajes que incluya el mensaje de sistema:
mensajes = [
{«role»: «system», «content»: «Eres un asistente útil especializado en Python. Responde de forma clara y concisa.»}
]
Luego modifica la función consultar_chatgpt() para que esta lista crezca con cada nuevo intercambio y se mantenga el historial conversacional:
def consultar_chatgpt(mensaje):
try:
mensajes.append({«role»: «user», «content»: mensaje})
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=mensajes
)
contenido = respuesta[«choices»][0][«message»][«content»]
mensajes.append({«role»: «assistant», «content»: contenido})
return contenido.strip()
except Exception as e:
return f»Ocurrió un error: {str(e)}»
Con esto lograrás que el asistente mantenga una coherencia de estilo, tono y ámbito durante toda la conversación, lo que resulta especialmente útil en proyectos temáticos, educativos o especializados.
Paso 10: Añadir entrada por voz desde el micrófono
Una forma más natural de interactuar con tu asistente es mediante comandos por voz. En este paso vamos a integrar reconocimiento de voz en tiempo real, para que puedas hablar al asistente y recibir respuestas sin usar el teclado.
Para lograrlo, utilizaremos la biblioteca SpeechRecognition, que permite capturar audio del micrófono y transcribirlo a texto usando la API de Google. También usaremos PyAudio como motor de acceso al hardware de entrada.
Primero, instala las dependencias necesarias:
pip install SpeechRecognition pyaudio
Luego, crea una función reconocer_voz() que active el micrófono, escuche tu voz y devuelva la transcripción:
import speech_recognition as sr
def reconocer_voz():
r = sr.Recognizer()
with sr.Microphone() as source:
print(«Habla ahora…»)
audio = r.listen(source)
try:
texto = r.recognize_google(audio, language=»es-ES»)
print(«Has dicho:», texto)
return texto
except sr.UnknownValueError:
print(«No se entendió el audio»)
except sr.RequestError as e:
print(«Error al conectar con el servicio de reconocimiento:», e)
Puedes integrar esta función dentro del flujo principal del asistente para ofrecer la opción de hablar en lugar de escribir. Por ejemplo, puedes mostrar un menú al usuario para elegir entre texto o voz, y en función de la elección, llamar a input() o a reconocer_voz().
Este tipo de interacción es especialmente útil para asistentes personales en móviles, kioscos o interfaces accesibles para personas con limitaciones de escritura.
Paso 11: Añadir persistencia básica del historial con archivos
Para dotar al asistente de una mínima memoria de conversación, puedes guardar los mensajes en un archivo local. De este modo, el asistente podrá recuperar interacciones anteriores y generar respuestas con un poco más de contexto.
En este paso aprenderás a registrar cada mensaje del usuario y del asistente en un archivo de texto (historial.txt) y a cargar ese contenido cuando inicies el programa. Aunque no será una memoria estructurada como una base de datos, permite retener información entre sesiones.
Primero, define una función para guardar cada intercambio en el historial:
def guardar_historial(usuario, asistente, archivo=’historial.txt’):
with open(archivo, ‘a’, encoding=’utf-8′) as f:
f.write(f»Tú: {usuario}n»)
f.write(f»Asistente: {asistente}nn»)
Después, otra función para cargar el historial desde el archivo al iniciar el programa:
def cargar_historial(archivo=’historial.txt’):
try:
with open(archivo, ‘r’, encoding=’utf-8′) as f:
return f.read()
except FileNotFoundError:
return «»
Finalmente, modifica el flujo principal del asistente para recuperar el historial, usarlo como parte del contexto (si así lo deseas), y actualizar el archivo después de cada respuesta.
if name == «main«:
historial = cargar_historial()
print(«Escribe tu mensaje o ‘salir’ para terminar.»)
while True:
entrada = input(«Tú: «)
if entrada.lower() in [«salir», «exit», «quit»]:
break
salida = consultar_chatgpt(entrada)
print(«Asistente:», salida)
guardar_historial(entrada, salida)
Este enfoque te permite mantener un registro simple y persistente de las conversaciones sin complicaciones técnicas. Más adelante podrás evolucionarlo a JSON o una base de datos relacional si lo necesitas.
Paso 12: Añadir memoria conversacional a corto plazo
Aunque guardar las conversaciones en un archivo es útil, no mejora las respuestas del asistente en tiempo real. Para lograr un comportamiento más natural, puedes implementar una memoria de corto plazo dentro de la misma sesión.
En este paso, aprenderás a mantener en memoria los últimos mensajes intercambiados con el asistente, enviándolos como contexto junto a cada nueva consulta. Esto permite que ChatGPT entienda mejor el flujo conversacional sin necesidad de acceso a archivos externos o bases de datos.
Primero, crea una lista global que actuará como historial temporal durante la ejecución del programa:
historial_conversacion = [
{«role»: «system», «content»: «Eres un asistente útil especializado en programación y Python. Responde de forma clara y breve.»}
]
Luego, ajusta la función consultar_chatgpt() para incluir esa lista de mensajes, con un límite de elementos para no saturar el contexto:
def consultar_chatgpt(mensaje):
try:
historial_conversacion.append({«role»: «user», «content»: mensaje})
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=historial_conversacion[-6:] # limitar a las últimas 6 interacciones
)
contenido = respuesta[«choices»][0][«message»][«content»]
historial_conversacion.append({«role»: «assistant», «content»: contenido})
return contenido.strip()
except Exception as e:
return f»Ocurrió un error: {str(e)}»
Finalmente, actualiza el bloque principal para mantener el flujo conversacional y actualizar la memoria de sesión:
if name == «main«:
print(«Escribe tu mensaje o ‘salir’ para terminar.»)
while True:
entrada = input(«Tú: «)
if entrada.lower() in [«salir», «exit», «quit»]:
break
salida = consultar_chatgpt(entrada)
print(«Asistente:», salida)
Esta memoria se borra al cerrar el programa, pero mejora mucho la calidad de la conversación mientras esté activa.
Paso 13: Guardar el historial de conversación en un archivo local
Si quieres conservar las conversaciones entre sesiones, puedes guardar el historial en un archivo de texto. Esto te permitirá registrar lo que se ha dicho y usar esa información para análisis, depuración o entrenamiento posterior.
En este paso, añadiremos dos funciones: una para guardar cada turno de conversación en un archivo y otra para cargar el historial completo si se desea reutilizar.
Primero, define la función que guarda los mensajes en un archivo de texto plano llamado chat_log.txt:
def guardar_en_historial(usuario, asistente, archivo=’chat_log.txt’):
with open(archivo, ‘a’, encoding=’utf-8′) as f:
f.write(f’Usuario: {usuario}n’)
f.write(f’Asistente: {asistente}nn’)
A continuación, puedes definir una función opcional para cargar el contenido completo del historial si necesitas consultarlo o usarlo como contexto:
def cargar_historial(archivo=’chat_log.txt’):
try:
with open(archivo, ‘r’, encoding=’utf-8′) as f:
return f.read()
except FileNotFoundError:
return «»
Estas funciones son especialmente útiles si quieres analizar conversaciones largas, auditar interacciones o construir una memoria persistente.
Paso 14: Añadir una interfaz por voz usando SpeechRecognition
Una forma de hacer más natural la interacción con tu asistente es habilitar el reconocimiento de voz. Para ello, utilizaremos la librería SpeechRecognition, que permite capturar audio desde el micrófono y convertirlo a texto usando servicios como Google Speech API.
Primero, asegúrate de tener instaladas las dependencias necesarias:
pip install SpeechRecognition pyaudio
A continuación, define una función reconocer_voz() que escuche por el micrófono y devuelva el texto transcrito. Añadiremos control de errores para mejorar la robustez del asistente:
import speech_recognition as sr
def reconocer_voz():
r = sr.Recognizer()
with sr.Microphone() as source:
print(«Habla ahora…»)
audio = r.listen(source)
try:
texto = r.recognize_google(audio, language=»es-ES»)
print(«Has dicho:», texto)
return texto
except sr.UnknownValueError:
print(«No se entendió el audio»)
return None
except sr.RequestError as e:
print(«Error al conectar con el servicio de reconocimiento:», e)
return None
Puedes integrar esta función con tu bucle conversacional para que, en lugar de teclear, el usuario pueda hablarle al asistente directamente.
Paso 15: Añadir persistencia básica de conversación con archivo de texto
Si quieres que tu asistente recuerde los mensajes anteriores durante la sesión o incluso entre ejecuciones, puedes implementar una persistencia básica utilizando archivos de texto. Esto permite almacenar el historial de conversación localmente y simular una memoria del asistente.
Vamos a crear dos funciones:
- guardar_en_historial(): guarda cada turno de conversación en un archivo.
- cargar_historial(): lee el contenido completo del historial para recuperarlo al iniciar.
Estas funciones permiten guardar lo que dice el usuario y el asistente, lo cual es útil para mantener el contexto o revisar sesiones anteriores.
def guardar_en_historial(usuario, asistente, archivo=’chat_log.txt’):
with open(archivo, ‘a’, encoding=’utf-8′) as f:
f.write(f’Usuario: {usuario}n’)
f.write(f’Asistente: {asistente}nn’)
def cargar_historial(archivo=’chat_log.txt’):
try:
with open(archivo, ‘r’, encoding=’utf-8′) as f:
return f.read()
except FileNotFoundError:
return «»
Después, puedes usar este historial como base de entrada para ChatGPT. Por ejemplo, puedes leer el historial antes de enviar la nueva consulta:
def ejecutar_asistente():
historial = cargar_historial()
while True:
prompt = input(«Tú: «)
if prompt.lower() in [‘salir’, ‘exit’]:
break
entrada = f»{historial}Usuario: {prompt}nAsistente:»
respuesta = obtener_respuesta(entrada)
print(«Asistente:», respuesta)
guardar_en_historial(prompt, respuesta)
historial += f»Usuario: {prompt}nAsistente: {respuesta}nn»
Este sistema de persistencia es simple pero muy eficaz para proyectos personales, y puede evolucionar fácilmente hacia almacenamiento en JSON o bases de datos si lo necesitas más adelante.
Paso 16: Añadir persistencia con archivos JSON para conservar el historial estructurado
Aunque guardar el historial en un archivo de texto plano es funcional, usar un archivo JSON ofrece una forma más estructurada de conservar los mensajes. Esto facilita operaciones como filtrar, ordenar o migrar el historial a otros formatos (como bases de datos).
Vamos a usar un archivo historial.json que almacenará una lista de diccionarios con los turnos de conversación. Cada mensaje tendrá al menos dos claves: role (usuario o asistente) y content (contenido del mensaje).
Primero, definimos dos funciones:
- guardar_historial_json(): guarda el historial completo en el archivo.
- cargar_historial_json(): carga el historial desde el archivo si existe, o lo inicializa si no.
import json
import os
HISTORIAL_JSON = «historial.json»
def guardar_historial_json(historial, archivo=HISTORIAL_JSON):
with open(archivo, «w», encoding=»utf-8″) as f:
json.dump(historial, f, ensure_ascii=False, indent=2)
def cargar_historial_json(archivo=HISTORIAL_JSON):
if os.path.exists(archivo):
with open(archivo, «r», encoding=»utf-8″) as f:
return json.load(f)
return []
Luego, al ejecutar el asistente, actualizamos el historial en memoria y lo guardamos tras cada interacción. También enviamos los últimos mensajes a la API para mantener el contexto.
def ejecutar_asistente_json():
historial = cargar_historial_json()
while True:
prompt = input(«Tú: «)
if prompt.lower() in [‘salir’, ‘exit’]:
break
historial.append({«role»: «user», «content»: prompt})
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=historial[-6:] # Solo enviamos las últimas 6 interacciones
)
content = respuesta[‘choices’][0][‘message’][‘content’]
historial.append({«role»: «assistant», «content»: content})
guardar_historial_json(historial)
print(«Asistente:», content)
Este enfoque permite conservar el historial entre sesiones, mantener el formato compatible con la API de OpenAI y escalar fácilmente hacia una base de datos o un sistema más avanzado en el futuro.
Paso 17: Añadir interfaz web con Gradio para facilitar el uso
Para que cualquier persona pueda interactuar fácilmente con tu asistente, puedes añadir una interfaz web básica usando Gradio. Esta librería permite construir interfaces visuales en pocos pasos, sin necesidad de HTML o JavaScript.
Vamos a crear una interfaz sencilla que permita introducir texto, enviar la consulta al asistente y mostrar la respuesta. Para ello:
- Instala Gradio con pip install gradio.
- Define una función que reciba el input del usuario y devuelva la respuesta generada.
- Lanza una interfaz con gr.Interface.
import gradio as gr
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv(«OPENAI_API_KEY»)
Memoria simple de la conversación
historial = []
def responder_gradio(mensaje):
historial.append({«role»: «user», «content»: mensaje})
mensajes_recientes = historial[-6:]
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=mensajes_recientes
)
contenido = respuesta[«choices»][0][«message»][«content»]
historial.append({«role»: «assistant», «content»: contenido})
return contenido
Si quieres que la conversación tenga algo de contexto, puedes almacenar los últimos turnos de diálogo en una lista compartida, que Gradio actualizará en cada llamada.
Este enfoque resulta ideal para demos, asistentes personales o herramientas internas, y se puede combinar con despliegue en local o en la nube.
Paso 18: Añadir entrada de voz con Gradio y reconocimiento de audio
Además de una interfaz escrita, puedes incorporar entrada de voz a tu asistente web usando Gradio junto con la librería SpeechRecognition. Esto permite hablarle directamente al asistente usando el micrófono, lo que mejora la accesibilidad y la naturalidad del uso.
Para implementarlo:
- Asegúrate de tener instalada la librería SpeechRecognition y sus dependencias.
- Configura una función que tome como entrada audio y lo transcriba a texto.
- Usa ese texto como input para consultar al asistente.
- Devuelve la respuesta generada y opcionalmente la transcripción.
Primero instala las dependencias necesarias:
pip install SpeechRecognition
pip install pydub
Luego crea una función de transcripción:
import speech_recognition as sr
def transcribir_audio(audio):
recognizer = sr.Recognizer()
with sr.AudioFile(audio) as source:
audio_data = recognizer.record(source)
try:
texto = recognizer.recognize_google(audio_data, language=»es-ES»)
return texto
except sr.UnknownValueError:
return «No se entendió el audio.»
except sr.RequestError:
return «Error al conectar con el servicio de reconocimiento.»
Crea una función que use esa transcripción como entrada al asistente:
def responder_desde_audio(audio):
texto = transcribir_audio(audio)
if texto.startswith(«Error») or texto.startswith(«No se»):
return texto
historial.append({«role»: «user», «content»: texto})
mensajes_recientes = historial[-6:]
respuesta = openai.ChatCompletion.create(
model=»gpt-3.5-turbo»,
messages=mensajes_recientes
)
contenido = respuesta[«choices»][0][«message»][«content»]
historial.append({«role»: «assistant», «content»: contenido})
return f»Tú dijiste: {texto}nnAsistente: {contenido}»
Y finalmente, genera la interfaz con Gradio para capturar audio desde el micrófono:
Interfaz por voz en Gradio
gr.Interface(
fn=responder_desde_audio,
inputs=gr.Audio(source=»microphone», type=»filepath»),
outputs=»text»,
title=»Asistente Virtual por Voz»,
description=»Habla al asistente y recibe una respuesta basada en ChatGPT.»
).launch()
Este tipo de funcionalidad es útil en entornos educativos, asistentes accesibles o interfaces móviles. Puedes extenderlo aún más incorporando síntesis de voz para que el asistente también hable.
Paso 19: Añadir comandos personalizados al asistente
Una forma sencilla de extender las capacidades de tu asistente es incorporar comandos personalizados que reconozca y ejecute antes de enviar la petición al modelo de lenguaje. Esto permite crear atajos, ejecutar funciones específicas o integrar utilidades propias.
En este ejemplo, implementaremos un sistema que detecta si el usuario escribe un comando como /hora o /saludo, y responde directamente desde el código sin necesidad de consultar a ChatGPT. Solo si no se trata de un comando, se enviará el mensaje al modelo.
Añade un bloque de lógica previa que detecte estas órdenes especiales y genere una respuesta inmediata. Puedes adaptar este sistema a tus propias necesidades o incluir comandos más avanzados conectados a APIs externas, sensores u otros servicios.
import datetime
def procesar_comando(mensaje):
if mensaje.startswith(«/hora»):
return f»La hora actual es {datetime.datetime.now().strftime(‘%H:%M:%S’)}»
elif mensaje.startswith(«/saludo»):
return «¡Hola! ¿En qué puedo ayudarte hoy?»
else:
return None
Uso combinado dentro del bucle principal
entrada = input(«Tú: «)
respuesta = procesar_comando(entrada)
if respuesta is None:
respuesta = consultar_chatgpt(entrada)
print(«Asistente:», respuesta)
Este enfoque ofrece una forma eficaz de ampliar funcionalidades sin necesidad de sobrecargar el modelo con tareas que puedes resolver directamente desde el código. Además, mejora el tiempo de respuesta y aporta una experiencia más natural para el usuario.
Paso 20: Añadir soporte multilenguaje al asistente
Una funcionalidad muy útil en asistentes conversacionales es la capacidad de operar en varios idiomas. Esto permite que el mismo asistente sea útil para usuarios de diferentes regiones o que se adapte automáticamente al idioma detectado en cada mensaje de entrada.
En este paso, implementaremos una función sencilla que detecta el idioma del mensaje del usuario utilizando la biblioteca langdetect. A partir de ese resultado, modificaremos dinámicamente el mensaje del sistema para que el modelo responda en el mismo idioma, manteniendo la coherencia en la conversación.
Antes de nada, asegúrate de
