Cómo crear un asistente de inteligencia artificial de voz agente que comprenda, razone, planifique y responda a través de inteligencia autónoma de varios pasos

importar subproceso importar sys importar json importar re desde fecha y hora importar fecha y hora desde escribir importar Dict, Lista, Tupla, Cualquier def install_packages(): paquetes = [‘transformers’, ‘torch’, ‘torchaudio’, ‘datasets’, ‘soundfile’,
‘librosa’, ‘IPython’, ‘numpy’]
para paquete en paquetes: subprocess.check_call([sys.executable, ‘-m’, ‘pip’, ‘install’, ‘-q’, pkg]) print(“🤖 Inicializando Agentic Voice AI…”) install_packages() importar antorcha importar archivo de sonido como sf importar numpy como np desde transformadores importar (AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline, SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan) desde IPython.display importar audio, visualización, advertencias de importación HTML advertencias.filterwarnings(‘ignorar’)

clase VoiceAgent: def __init__(self): self.memory = []
self.context = {} self.tools = {} self.goals = []

def percibir(self, audio_input: str) -> Dict[str, Any]: intención = self._extract_intent(audio_input) entidades = self._extract_entities(audio_input) sentimiento = self._analyze_sentiment(audio_input) percepción = { ‘texto’: audio_input, ‘intención’: intención, ‘entidades’: entidades, ‘sentimiento’: sentimiento, ‘marca de tiempo’: datetime.now().isoformat() } self.memory.append(percepción) devolver percepción def _extract_intent(self, text: str) -> str: text_lower = text.lower() intent_patterns = { ‘create’: [‘create’, ‘make’, ‘generate’, ‘write’]’buscar’: [‘search’, ‘find’, ‘look for’, ‘show me’]’analizar’: [‘analyze’, ‘explain’, ‘understand’, ‘what is’]’calcular’: [‘calculate’, ‘compute’, ‘how much’, ‘sum’]’cronograma’: [‘schedule’, ‘plan’, ‘set reminder’, ‘meeting’]’traducir’: [‘translate’, ‘say in’, ‘convert to’]’resumir’: [‘summarize’, ‘brief’, ‘tldr’, ‘overview’]
} para intención, palabras clave en intent_patterns.items(): si las hay (kw en text_lower para kw en palabras clave): devolver intención devolver ‘conversación’ def _extract_entities(self, texto: str) -> Dict[str, List[str]]: entidades = { ‘números’: re.findall(r’\d+’, texto), ‘fechas’: re.findall(r’\b\d{1,2}/\d{1,2}/\d{2,4}\b’, texto), ‘horas’: re.findall(r’\b\d{1,2}:\d{2}\s*(?:am|pm)?\b’, text.lower()), ‘correos electrónicos’: re.findall(r’\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b’, texto) } return {k: v para k, v en entidades.items() si v} def _analyze_sentiment(self, texto: str) -> str: positivo = [‘good’, ‘great’, ‘excellent’, ‘happy’, ‘love’, ‘thank’]
negativo = [‘bad’, ‘terrible’, ‘sad’, ‘hate’, ‘angry’, ‘problem’]
text_lower = text.lower() pos_count = suma(1 para palabra en positivo si palabra en text_lower) neg_count = suma(1 para palabra en negativo si palabra en text_lower) if pos_count > neg_count: devuelve ‘positivo’ elif neg_count > pos_count: devuelve ‘negativo’ devuelve ‘neutral’

def razón(yo, percepción: Dict) -> Dict[str, Any]: intención = percepción[‘intent’]
razonamiento = { ‘objetivo’: self._identify_goal(intención), ‘prerrequisitos’: self._check_prequires(intención), ‘plan’: self._create_plan(intención, percepción[‘entities’]), ‘confianza’: self._calculate_confidence(perception) } return razonamiento def act(self, razonamiento: Dict) -> str: plan = razonamiento[‘plan’]
resultados = []
para el paso en el plan[‘steps’]: resultado = self._execute_step(paso) resultados.append(resultado) respuesta = self._generate_response(resultados, razonamiento) devolver respuesta def _identify_goal(self, intención: str) -> str: goal_mapping = { ‘crear’: ‘Generar nuevo contenido’, ‘buscar’: ‘Recuperar información’, ‘analizar’: ‘Comprender y explicar’, ‘calcular’: ‘Realizar cálculo’, ‘programar’: ‘Organizar tareas basadas en tiempo’, ‘traducir’: ‘Convertir entre idiomas’, ‘resumir’: ‘Condensar información’ } return goal_mapping.get(intent, ‘Asistir al usuario’) def _check_prequires(self, intent: str) -> Lista[str]: requisitos previos = { ‘buscar’: [‘internet access’, ‘search tool’]’calcular’: [‘math processor’]’traducir’: [‘translation model’]’cronograma’: [‘calendar access’]
} devolver prereqs.get(intención, [‘language understanding’]) def _create_plan(self, intención: str, entidades: Dict) -> Dict: planes = { ‘crear’: {‘pasos’: [‘understand_requirements’, ‘generate_content’, ‘validate_output’]’tiempo_estimado’: ’10s’}, ‘analizar’: {‘pasos’: [‘parse_input’, ‘analyze_components’, ‘synthesize_explanation’]’tiempo_estimado’: ‘5s’}, ‘calcular’: {‘pasos’: [‘extract_numbers’, ‘determine_operation’, ‘compute_result’]’tiempo_estimado’: ‘2s’} } plan_predeterminado = {‘pasos’: [‘understand_query’, ‘process_information’, ‘formulate_response’]’tiempo_estimado’: ‘3s’} planes de retorno.get(intención, plan_predeterminado)

def _calculate_confidence(self, percepción: Dict) -> float: base_confidence = 0.7 si percepción[‘entities’]: base_confidence += 0.15 si percepción[‘sentiment’] != ‘neutral’: base_confidence += 0.1 si len(percepción[‘text’].split()) > 5: base_confidence += 0.05 return min(base_confidence, 1.0) def _execute_step(self, paso: str) -> Dict: return {‘step’: paso, ‘status’: ‘completado’, ‘salida’: f’Ejecutado {paso}’} def _generate_response(self, resultados: Lista, razonamiento: Dict) -> str: intención = razonamiento[‘goal’]
confianza = razonamiento[‘confidence’]
prefijo = “Entiendo que quieres” if confianza > 0.8 else “Creo que me estás pidiendo que lo haga” respuesta = f”{prefijo} {intención.lower()}. ” if len(self.memory) > 1: respuesta += “Basado en nuestra conversación, ” respuesta += f”He analizado tu solicitud y completé {len(resultados)} pasos. ” devolver respuesta

clase VoiceIO: def __init__(self): print(“Cargando modelos de voz…”) dispositivo = “cuda:0” if torch.cuda.is_available() else “cpu” self.stt_pipe = pipeline(“reconocimiento-automático-de-voz”, model=”openai/whisper-base”, dispositivo=dispositivo) self.tts_processor = SpeechT5Processor.from_pretrained(“microsoft/speecht5_tts”) self.tts_model = SpeechT5ForTextToSpeech.from_pretrained(“microsoft/speecht5_tts”) self.vocoder = SpeechT5HifiGan.from_pretrained(“microsoft/speecht5_hifigan”) self.speaker_embeddings = torch.randn(1, 512) * 0.1 print(” ✓ E/S de voz lista”) def listening(self, audio_path: str) -> str: result = self.stt_pipe(audio_path) devuelve resultado[‘text’]

def hablar(self, texto: str, ruta_salida: str = “respuesta.wav”) -> Tupla[str, np.ndarray]: entradas = self.tts_processor(texto=texto, return_tensors=”pt”) voz = self.tts_model.generate_speech(entradas[“input_ids”]self.speaker_embeddings, vocoder=self.vocoder) sf.write(output_path, Speech.numpy(), samplerate=16000) devuelve Output_path, Speech.numpy() clase AgenticVoiceAssistant: def __init__(self): self.agent = VoiceAgent() self.voice_io = VoiceIO() self.interaction_count = 0 def Process_voice_input(self, audio_path: str) -> Dict: text_input = self.voice_io.listen(audio_path) percepción = self.agent.perceive(text_input) razonamiento = self.agent.reason(percepción) respuesta_texto = self.agent.act(razonamiento) audio_path, audio_array = self.voice_io.speak(response_text) self.interaction_count += 1 return { ‘input_text’: text_input, ‘percepción’: percepción, ‘razonamiento’: razonamiento, ‘response_text’: respuesta_text, ‘audio_path’: audio_path, ‘audio_array’: audio_array}

def display_reasoning(self, resultado: Dict): html = f”””

“”” display(HTML(html)) def run_agentic_demo(): print(“\n” + “=”*70) print(“🤖 ASISTENTE AI DE VOZ AGÉNTICA”) print(“=”*70 + “\n”) asistente = AgenticVoiceAssistant() escenarios = [
“Create a summary of machine learning concepts”,
“Calculate the sum of twenty five and thirty seven”,
“Analyze the benefits of renewable energy”
]
para i, texto_escenario en enumerar(escenarios, 1): print(f”\n— Escenario {i} —“) print(f”Entrada simulada: ‘{escenario_text}'”) ruta_audio, _ = asistente.voice_io.speak(texto_escenario, f”input_{i}.wav”) resultado = asistente.proceso_voz_input(ruta_audio) asistente.display_reasoning(resultado) print(“\n🔊 Reproduciendo la respuesta de voz del agente…”) display(Audio(resultado[‘audio_array’]rate=16000)) print(“\n” + “-“*70) print(f”\n✅ {assistant.interaction_count} interacciones de agente completadas”) print(“\n🎯 Capacidades de agente clave demostradas:”) print(” • Percepción y comprensión autónomas”) print(” • Reconocimiento de intenciones y extracción de entidades”) print(” • Razonamiento y planificación de varios pasos”) print(” • Ejecución de acciones basadas en objetivos”) print(” • Lenguaje natural generación de respuesta”) print(” • Gestión de memoria y contexto”) if __name__ == “__main__”: run_agentic_demo()