Click here to view the next lesson.

Proyecto: Grabadora de Asistente de Voz — Utilizar Whisper + GPT-4o para Transcribir, Resumir y Analizar

Código del Proyecto

Descarga la muestra de audio: https://files.cuantum.tech/audio/voice_recording.mp3

import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime

# --- Configuration ---
load_dotenv()

# Get the current date and location context
current_timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")
current_location = "Houston, Texas, United States" # User location context
print(f"Running Voice Assistant Recorder project at: {current_timestamp}")
print(f"Location Context: {current_location}")


# Initialize the OpenAI client
try:
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not found in environment variables.")
    client = OpenAI(api_key=api_key)
    print("OpenAI client initialized.")
except ValueError as e:
    print(f"Configuration Error: {e}")
    exit()
except Exception as e:
    print(f"Error initializing OpenAI client: {e}")
    exit()

# Define the path to the input audio file
# IMPORTANT: Replace 'voice_recording.mp3' with the actual filename.
#            Ensure this file exists in the same directory.
audio_file_path = "voice_recording.mp3"

# --- Prerequisites Check ---
if not os.path.exists(audio_file_path):
    print(f"\nError: Input audio file not found at '{audio_file_path}'")
    print("Please make sure the audio file exists and the path is correct.")
    exit()

# --- Step 1: Transcribe Audio using Whisper ---
def transcribe_audio(client, file_path):
    """Transcribes the audio file using Whisper."""
    print(f"\nStep 1: Transcribing audio file: {file_path}")
    # Add note about chunking for long files if size check implemented
    try:
        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
        print(f"File size: {file_size_mb:.2f} MB (Whisper Limit: 25MB per API call)")
        if file_size_mb > 25:
             print("Warning: File exceeds 25MB. Consider chunking for full transcription.")
             # You might want to handle this case differently, e.g., only process first 25MB
    except OSError:
        pass # Ignore size check error

    try:
        with open(file_path, "rb") as audio_file:
            response = client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file,
                response_format="text"
            )
        print("Transcription successful.")
        return response # Returns plain text
    except OpenAIError as e:
        print(f"OpenAI API Error during transcription: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during transcription: {e}")
        return None

# --- Step 2: Summarize Transcription using GPT-4o ---
def summarize_text(client, text_to_summarize):
    """Generates a concise summary of the provided text using GPT-4o."""
    print("\nStep 2: Generating summary...")
    if not text_to_summarize:
        print("Error: No text provided for summarization.")
        return None

    system_prompt = "You are an expert summarizer. Create a concise summary of the following text."
    user_prompt = f"""Please provide a brief summary (1-3 sentences) of the key points in the following transcription:

Transcription:
---
{text_to_summarize}
---

Summary:
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=150,
            temperature=0.5
        )
        summary = response.choices[0].message.content
        print("Summary generation successful.")
        return summary.strip()
    except OpenAIError as e:
        print(f"OpenAI API Error during summarization: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during summarization: {e}")
        return None

# --- Step 3: (Optional) Extract Action Items using GPT-4o ---
def extract_action_items(client, text_to_analyze):
    """Identifies and extracts action items from the text using GPT-4o."""
    print("\nStep 3: Extracting action items (Optional)...")
    if not text_to_analyze:
        print("Error: No text provided for extraction.")
        return None

    system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
    user_prompt = f"""Analyze the following transcription. List any specific action items mentioned. Include who is assigned (if stated) and any deadlines (if stated). If no action items are found, state "None identified".

Transcription Text:
---
{text_to_analyze}
---

Extracted Action Items (Format as a list):
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=300,
            temperature=0.1 # Low temp for factual extraction
        )
        action_items = response.choices[0].message.content
        # Check if GPT actually found items or returned "None identified" etc.
        if "none identified" in action_items.lower() and len(action_items) < 30:
             print("No specific action items identified by the model.")
             return None # Return None if no items found
        else:
             print("Action item extraction successful.")
             return action_items.strip()

    except OpenAIError as e:
        print(f"OpenAI API Error during action item extraction: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during action item extraction: {e}")
        return None

# --- Main Execution Logic ---
if __name__ == "__main__":
    print(f"\nProcessing audio file: {audio_file_path}")

    # 1. Transcribe
    transcription = transcribe_audio(client, audio_file_path)

    if transcription:
        print(f"\n--- Full Transcription ---")
        print(transcription)
        print("-" * 26)

        # 2. Summarize
        summary = summarize_text(client, transcription)
        if summary:
            print(f"\n--- Summary ---")
            print(summary)
            print("-" * 13)

        # 3. Extract Action Items (Optional Step)
        action_items = extract_action_items(client, transcription)
        if action_items:
            print(f"\n--- Action Items ---")
            print(action_items)
            print("-" * 18)
        else:
            # This is expected if no action items were in the audio/transcription
            print("\nNo specific action items were extracted.")

        print("\n--- Processing Complete ---")

    else:
        print("\nProcessing failed due to transcription error.")

Explicación del Desglose del Código

Este script de Python implementa el proyecto "Grabadora con Asistente de Voz", procesando un archivo de audio para generar una transcripción, resumen y, opcionalmente, una lista de elementos de acción.

Configuración e Inicialización:
- Importaciones: Importa las bibliotecas necesarias: os (para verificación de rutas de archivo), openai, dotenv (para la clave API), datetime, y OpenAIError.
- Clave API y Cliente: Carga la clave API de OpenAI desde un archivo .env e inicializa el objeto cliente OpenAI (client) para interacciones con la API. Incluye manejo de errores para claves faltantes o fallos de inicialización.
- Ruta del Archivo: Define la variable audio_file_path, que apunta al archivo de grabación de voz de entrada.
- Verificación de Prerrequisitos: Incluye una verificación básica usando os.path.exists() para asegurar que el archivo de audio especificado realmente existe antes de continuar.
Paso 1: Transcribir Audio (función transcribe_audio):
- Propósito: Convierte el archivo de audio de entrada en texto usando Whisper.
- Entrada: Toma el objeto client y la file_path del audio.
- Manejo de Archivos: Abre el archivo de audio en modo lectura binaria ("rb"). Incluye una verificación opcional del tamaño del archivo y advertencia sobre el límite de 25MB de Whisper.
- Llamada API: Utiliza client.audio.transcriptions.create con model="whisper-1" y response_format="text".
- Salida: Devuelve la transcripción como texto plano en forma de cadena, o None si ocurre un error.
Paso 2: Resumir Transcripción (función summarize_text):
- Propósito: Crea un resumen conciso del texto transcrito usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_summarize (la salida de Whisper).
- Ingeniería de Prompt: Construye un prompt que instruye a GPT-4o para actuar como un experto en resúmenes y proporcionar un resumen breve (1-3 oraciones) de los puntos clave de la transcripción proporcionada.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o", los prompts de sistema/usuario, y configuraciones apropiadas de max_tokens y temperature para la generación del resumen.
- Salida: Devuelve el texto del resumen generado como una cadena, o None en caso de error.
Paso 3: Extraer Elementos de Acción (función extract_action_items - Opcional):
- Propósito: Identifica y enumera tareas específicas o compromisos mencionados en la transcripción usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_analyze (la transcripción).
- Ingeniería de Prompt: Utiliza un prompt específicamente diseñado para instruir a GPT-4o a encontrar elementos de acción, incluyendo la persona asignada y la fecha límite si se mencionan, y formatearlos como una lista. También pide al modelo distinguir entre tareas y sugerencias, y declarar "Ninguno identificado" si corresponde. Se usa una temperature baja (0.1) para una extracción más factual.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o".
- Salida: Devuelve la lista de elementos de acción como una cadena. Incluye una verificación básica para devolver None si el modelo indica explícitamente que no se encontraron elementos, evitando imprimir solo "Ninguno identificado".
Ejecución Principal (if __name__ == "__main__":):
- Orquestación: Este bloque controla el flujo general.
- Llama primero a transcribe_audio.
- Si la transcripción es exitosa, procede a llamar a summarize_text.
- Luego llama a extract_action_items.
- Visualización de Salida: Imprime la transcripción completa, el resumen generado y los elementos de acción extraídos (si se encontraron) en la consola con encabezados claros.
- Manejo de Errores: Incluye verificaciones básicas para asegurar que los pasos solo se ejecuten si el paso anterior fue exitoso y proporciona mensajes si el procesamiento falla.

Este script proporciona un flujo de trabajo claro para transformar grabaciones de voz sin procesar en información estructurada y procesable utilizando el poder combinado de Whisper y GPT-4o.

Código del Proyecto

Descarga la muestra de audio: https://files.cuantum.tech/audio/voice_recording.mp3

import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime

# --- Configuration ---
load_dotenv()

# Get the current date and location context
current_timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")
current_location = "Houston, Texas, United States" # User location context
print(f"Running Voice Assistant Recorder project at: {current_timestamp}")
print(f"Location Context: {current_location}")


# Initialize the OpenAI client
try:
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not found in environment variables.")
    client = OpenAI(api_key=api_key)
    print("OpenAI client initialized.")
except ValueError as e:
    print(f"Configuration Error: {e}")
    exit()
except Exception as e:
    print(f"Error initializing OpenAI client: {e}")
    exit()

# Define the path to the input audio file
# IMPORTANT: Replace 'voice_recording.mp3' with the actual filename.
#            Ensure this file exists in the same directory.
audio_file_path = "voice_recording.mp3"

# --- Prerequisites Check ---
if not os.path.exists(audio_file_path):
    print(f"\nError: Input audio file not found at '{audio_file_path}'")
    print("Please make sure the audio file exists and the path is correct.")
    exit()

# --- Step 1: Transcribe Audio using Whisper ---
def transcribe_audio(client, file_path):
    """Transcribes the audio file using Whisper."""
    print(f"\nStep 1: Transcribing audio file: {file_path}")
    # Add note about chunking for long files if size check implemented
    try:
        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
        print(f"File size: {file_size_mb:.2f} MB (Whisper Limit: 25MB per API call)")
        if file_size_mb > 25:
             print("Warning: File exceeds 25MB. Consider chunking for full transcription.")
             # You might want to handle this case differently, e.g., only process first 25MB
    except OSError:
        pass # Ignore size check error

    try:
        with open(file_path, "rb") as audio_file:
            response = client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file,
                response_format="text"
            )
        print("Transcription successful.")
        return response # Returns plain text
    except OpenAIError as e:
        print(f"OpenAI API Error during transcription: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during transcription: {e}")
        return None

# --- Step 2: Summarize Transcription using GPT-4o ---
def summarize_text(client, text_to_summarize):
    """Generates a concise summary of the provided text using GPT-4o."""
    print("\nStep 2: Generating summary...")
    if not text_to_summarize:
        print("Error: No text provided for summarization.")
        return None

    system_prompt = "You are an expert summarizer. Create a concise summary of the following text."
    user_prompt = f"""Please provide a brief summary (1-3 sentences) of the key points in the following transcription:

Transcription:
---
{text_to_summarize}
---

Summary:
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=150,
            temperature=0.5
        )
        summary = response.choices[0].message.content
        print("Summary generation successful.")
        return summary.strip()
    except OpenAIError as e:
        print(f"OpenAI API Error during summarization: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during summarization: {e}")
        return None

# --- Step 3: (Optional) Extract Action Items using GPT-4o ---
def extract_action_items(client, text_to_analyze):
    """Identifies and extracts action items from the text using GPT-4o."""
    print("\nStep 3: Extracting action items (Optional)...")
    if not text_to_analyze:
        print("Error: No text provided for extraction.")
        return None

    system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
    user_prompt = f"""Analyze the following transcription. List any specific action items mentioned. Include who is assigned (if stated) and any deadlines (if stated). If no action items are found, state "None identified".

Transcription Text:
---
{text_to_analyze}
---

Extracted Action Items (Format as a list):
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=300,
            temperature=0.1 # Low temp for factual extraction
        )
        action_items = response.choices[0].message.content
        # Check if GPT actually found items or returned "None identified" etc.
        if "none identified" in action_items.lower() and len(action_items) < 30:
             print("No specific action items identified by the model.")
             return None # Return None if no items found
        else:
             print("Action item extraction successful.")
             return action_items.strip()

    except OpenAIError as e:
        print(f"OpenAI API Error during action item extraction: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during action item extraction: {e}")
        return None

# --- Main Execution Logic ---
if __name__ == "__main__":
    print(f"\nProcessing audio file: {audio_file_path}")

    # 1. Transcribe
    transcription = transcribe_audio(client, audio_file_path)

    if transcription:
        print(f"\n--- Full Transcription ---")
        print(transcription)
        print("-" * 26)

        # 2. Summarize
        summary = summarize_text(client, transcription)
        if summary:
            print(f"\n--- Summary ---")
            print(summary)
            print("-" * 13)

        # 3. Extract Action Items (Optional Step)
        action_items = extract_action_items(client, transcription)
        if action_items:
            print(f"\n--- Action Items ---")
            print(action_items)
            print("-" * 18)
        else:
            # This is expected if no action items were in the audio/transcription
            print("\nNo specific action items were extracted.")

        print("\n--- Processing Complete ---")

    else:
        print("\nProcessing failed due to transcription error.")

Explicación del Desglose del Código

Configuración e Inicialización:
- Importaciones: Importa las bibliotecas necesarias: os (para verificación de rutas de archivo), openai, dotenv (para la clave API), datetime, y OpenAIError.
- Clave API y Cliente: Carga la clave API de OpenAI desde un archivo .env e inicializa el objeto cliente OpenAI (client) para interacciones con la API. Incluye manejo de errores para claves faltantes o fallos de inicialización.
- Ruta del Archivo: Define la variable audio_file_path, que apunta al archivo de grabación de voz de entrada.
- Verificación de Prerrequisitos: Incluye una verificación básica usando os.path.exists() para asegurar que el archivo de audio especificado realmente existe antes de continuar.
Paso 1: Transcribir Audio (función transcribe_audio):
- Propósito: Convierte el archivo de audio de entrada en texto usando Whisper.
- Entrada: Toma el objeto client y la file_path del audio.
- Manejo de Archivos: Abre el archivo de audio en modo lectura binaria ("rb"). Incluye una verificación opcional del tamaño del archivo y advertencia sobre el límite de 25MB de Whisper.
- Llamada API: Utiliza client.audio.transcriptions.create con model="whisper-1" y response_format="text".
- Salida: Devuelve la transcripción como texto plano en forma de cadena, o None si ocurre un error.
Paso 2: Resumir Transcripción (función summarize_text):
- Propósito: Crea un resumen conciso del texto transcrito usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_summarize (la salida de Whisper).
- Ingeniería de Prompt: Construye un prompt que instruye a GPT-4o para actuar como un experto en resúmenes y proporcionar un resumen breve (1-3 oraciones) de los puntos clave de la transcripción proporcionada.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o", los prompts de sistema/usuario, y configuraciones apropiadas de max_tokens y temperature para la generación del resumen.
- Salida: Devuelve el texto del resumen generado como una cadena, o None en caso de error.
Paso 3: Extraer Elementos de Acción (función extract_action_items - Opcional):
- Propósito: Identifica y enumera tareas específicas o compromisos mencionados en la transcripción usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_analyze (la transcripción).
- Ingeniería de Prompt: Utiliza un prompt específicamente diseñado para instruir a GPT-4o a encontrar elementos de acción, incluyendo la persona asignada y la fecha límite si se mencionan, y formatearlos como una lista. También pide al modelo distinguir entre tareas y sugerencias, y declarar "Ninguno identificado" si corresponde. Se usa una temperature baja (0.1) para una extracción más factual.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o".
- Salida: Devuelve la lista de elementos de acción como una cadena. Incluye una verificación básica para devolver None si el modelo indica explícitamente que no se encontraron elementos, evitando imprimir solo "Ninguno identificado".
Ejecución Principal (if __name__ == "__main__":):
- Orquestación: Este bloque controla el flujo general.
- Llama primero a transcribe_audio.
- Si la transcripción es exitosa, procede a llamar a summarize_text.
- Luego llama a extract_action_items.
- Visualización de Salida: Imprime la transcripción completa, el resumen generado y los elementos de acción extraídos (si se encontraron) en la consola con encabezados claros.
- Manejo de Errores: Incluye verificaciones básicas para asegurar que los pasos solo se ejecuten si el paso anterior fue exitoso y proporciona mensajes si el procesamiento falla.

Este script proporciona un flujo de trabajo claro para transformar grabaciones de voz sin procesar en información estructurada y procesable utilizando el poder combinado de Whisper y GPT-4o.

Código del Proyecto

Descarga la muestra de audio: https://files.cuantum.tech/audio/voice_recording.mp3

import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime

# --- Configuration ---
load_dotenv()

# Get the current date and location context
current_timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")
current_location = "Houston, Texas, United States" # User location context
print(f"Running Voice Assistant Recorder project at: {current_timestamp}")
print(f"Location Context: {current_location}")


# Initialize the OpenAI client
try:
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not found in environment variables.")
    client = OpenAI(api_key=api_key)
    print("OpenAI client initialized.")
except ValueError as e:
    print(f"Configuration Error: {e}")
    exit()
except Exception as e:
    print(f"Error initializing OpenAI client: {e}")
    exit()

# Define the path to the input audio file
# IMPORTANT: Replace 'voice_recording.mp3' with the actual filename.
#            Ensure this file exists in the same directory.
audio_file_path = "voice_recording.mp3"

# --- Prerequisites Check ---
if not os.path.exists(audio_file_path):
    print(f"\nError: Input audio file not found at '{audio_file_path}'")
    print("Please make sure the audio file exists and the path is correct.")
    exit()

# --- Step 1: Transcribe Audio using Whisper ---
def transcribe_audio(client, file_path):
    """Transcribes the audio file using Whisper."""
    print(f"\nStep 1: Transcribing audio file: {file_path}")
    # Add note about chunking for long files if size check implemented
    try:
        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
        print(f"File size: {file_size_mb:.2f} MB (Whisper Limit: 25MB per API call)")
        if file_size_mb > 25:
             print("Warning: File exceeds 25MB. Consider chunking for full transcription.")
             # You might want to handle this case differently, e.g., only process first 25MB
    except OSError:
        pass # Ignore size check error

    try:
        with open(file_path, "rb") as audio_file:
            response = client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file,
                response_format="text"
            )
        print("Transcription successful.")
        return response # Returns plain text
    except OpenAIError as e:
        print(f"OpenAI API Error during transcription: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during transcription: {e}")
        return None

# --- Step 2: Summarize Transcription using GPT-4o ---
def summarize_text(client, text_to_summarize):
    """Generates a concise summary of the provided text using GPT-4o."""
    print("\nStep 2: Generating summary...")
    if not text_to_summarize:
        print("Error: No text provided for summarization.")
        return None

    system_prompt = "You are an expert summarizer. Create a concise summary of the following text."
    user_prompt = f"""Please provide a brief summary (1-3 sentences) of the key points in the following transcription:

Transcription:
---
{text_to_summarize}
---

Summary:
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=150,
            temperature=0.5
        )
        summary = response.choices[0].message.content
        print("Summary generation successful.")
        return summary.strip()
    except OpenAIError as e:
        print(f"OpenAI API Error during summarization: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during summarization: {e}")
        return None

# --- Step 3: (Optional) Extract Action Items using GPT-4o ---
def extract_action_items(client, text_to_analyze):
    """Identifies and extracts action items from the text using GPT-4o."""
    print("\nStep 3: Extracting action items (Optional)...")
    if not text_to_analyze:
        print("Error: No text provided for extraction.")
        return None

    system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
    user_prompt = f"""Analyze the following transcription. List any specific action items mentioned. Include who is assigned (if stated) and any deadlines (if stated). If no action items are found, state "None identified".

Transcription Text:
---
{text_to_analyze}
---

Extracted Action Items (Format as a list):
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=300,
            temperature=0.1 # Low temp for factual extraction
        )
        action_items = response.choices[0].message.content
        # Check if GPT actually found items or returned "None identified" etc.
        if "none identified" in action_items.lower() and len(action_items) < 30:
             print("No specific action items identified by the model.")
             return None # Return None if no items found
        else:
             print("Action item extraction successful.")
             return action_items.strip()

    except OpenAIError as e:
        print(f"OpenAI API Error during action item extraction: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during action item extraction: {e}")
        return None

# --- Main Execution Logic ---
if __name__ == "__main__":
    print(f"\nProcessing audio file: {audio_file_path}")

    # 1. Transcribe
    transcription = transcribe_audio(client, audio_file_path)

    if transcription:
        print(f"\n--- Full Transcription ---")
        print(transcription)
        print("-" * 26)

        # 2. Summarize
        summary = summarize_text(client, transcription)
        if summary:
            print(f"\n--- Summary ---")
            print(summary)
            print("-" * 13)

        # 3. Extract Action Items (Optional Step)
        action_items = extract_action_items(client, transcription)
        if action_items:
            print(f"\n--- Action Items ---")
            print(action_items)
            print("-" * 18)
        else:
            # This is expected if no action items were in the audio/transcription
            print("\nNo specific action items were extracted.")

        print("\n--- Processing Complete ---")

    else:
        print("\nProcessing failed due to transcription error.")

Explicación del Desglose del Código

Configuración e Inicialización:
- Importaciones: Importa las bibliotecas necesarias: os (para verificación de rutas de archivo), openai, dotenv (para la clave API), datetime, y OpenAIError.
- Clave API y Cliente: Carga la clave API de OpenAI desde un archivo .env e inicializa el objeto cliente OpenAI (client) para interacciones con la API. Incluye manejo de errores para claves faltantes o fallos de inicialización.
- Ruta del Archivo: Define la variable audio_file_path, que apunta al archivo de grabación de voz de entrada.
- Verificación de Prerrequisitos: Incluye una verificación básica usando os.path.exists() para asegurar que el archivo de audio especificado realmente existe antes de continuar.
Paso 1: Transcribir Audio (función transcribe_audio):
- Propósito: Convierte el archivo de audio de entrada en texto usando Whisper.
- Entrada: Toma el objeto client y la file_path del audio.
- Manejo de Archivos: Abre el archivo de audio en modo lectura binaria ("rb"). Incluye una verificación opcional del tamaño del archivo y advertencia sobre el límite de 25MB de Whisper.
- Llamada API: Utiliza client.audio.transcriptions.create con model="whisper-1" y response_format="text".
- Salida: Devuelve la transcripción como texto plano en forma de cadena, o None si ocurre un error.
Paso 2: Resumir Transcripción (función summarize_text):
- Propósito: Crea un resumen conciso del texto transcrito usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_summarize (la salida de Whisper).
- Ingeniería de Prompt: Construye un prompt que instruye a GPT-4o para actuar como un experto en resúmenes y proporcionar un resumen breve (1-3 oraciones) de los puntos clave de la transcripción proporcionada.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o", los prompts de sistema/usuario, y configuraciones apropiadas de max_tokens y temperature para la generación del resumen.
- Salida: Devuelve el texto del resumen generado como una cadena, o None en caso de error.
Paso 3: Extraer Elementos de Acción (función extract_action_items - Opcional):
- Propósito: Identifica y enumera tareas específicas o compromisos mencionados en la transcripción usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_analyze (la transcripción).
- Ingeniería de Prompt: Utiliza un prompt específicamente diseñado para instruir a GPT-4o a encontrar elementos de acción, incluyendo la persona asignada y la fecha límite si se mencionan, y formatearlos como una lista. También pide al modelo distinguir entre tareas y sugerencias, y declarar "Ninguno identificado" si corresponde. Se usa una temperature baja (0.1) para una extracción más factual.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o".
- Salida: Devuelve la lista de elementos de acción como una cadena. Incluye una verificación básica para devolver None si el modelo indica explícitamente que no se encontraron elementos, evitando imprimir solo "Ninguno identificado".
Ejecución Principal (if __name__ == "__main__":):
- Orquestación: Este bloque controla el flujo general.
- Llama primero a transcribe_audio.
- Si la transcripción es exitosa, procede a llamar a summarize_text.
- Luego llama a extract_action_items.
- Visualización de Salida: Imprime la transcripción completa, el resumen generado y los elementos de acción extraídos (si se encontraron) en la consola con encabezados claros.
- Manejo de Errores: Incluye verificaciones básicas para asegurar que los pasos solo se ejecuten si el paso anterior fue exitoso y proporciona mensajes si el procesamiento falla.

Este script proporciona un flujo de trabajo claro para transformar grabaciones de voz sin procesar en información estructurada y procesable utilizando el poder combinado de Whisper y GPT-4o.

Código del Proyecto

Descarga la muestra de audio: https://files.cuantum.tech/audio/voice_recording.mp3

import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime

# --- Configuration ---
load_dotenv()

# Get the current date and location context
current_timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")
current_location = "Houston, Texas, United States" # User location context
print(f"Running Voice Assistant Recorder project at: {current_timestamp}")
print(f"Location Context: {current_location}")


# Initialize the OpenAI client
try:
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not found in environment variables.")
    client = OpenAI(api_key=api_key)
    print("OpenAI client initialized.")
except ValueError as e:
    print(f"Configuration Error: {e}")
    exit()
except Exception as e:
    print(f"Error initializing OpenAI client: {e}")
    exit()

# Define the path to the input audio file
# IMPORTANT: Replace 'voice_recording.mp3' with the actual filename.
#            Ensure this file exists in the same directory.
audio_file_path = "voice_recording.mp3"

# --- Prerequisites Check ---
if not os.path.exists(audio_file_path):
    print(f"\nError: Input audio file not found at '{audio_file_path}'")
    print("Please make sure the audio file exists and the path is correct.")
    exit()

# --- Step 1: Transcribe Audio using Whisper ---
def transcribe_audio(client, file_path):
    """Transcribes the audio file using Whisper."""
    print(f"\nStep 1: Transcribing audio file: {file_path}")
    # Add note about chunking for long files if size check implemented
    try:
        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
        print(f"File size: {file_size_mb:.2f} MB (Whisper Limit: 25MB per API call)")
        if file_size_mb > 25:
             print("Warning: File exceeds 25MB. Consider chunking for full transcription.")
             # You might want to handle this case differently, e.g., only process first 25MB
    except OSError:
        pass # Ignore size check error

    try:
        with open(file_path, "rb") as audio_file:
            response = client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file,
                response_format="text"
            )
        print("Transcription successful.")
        return response # Returns plain text
    except OpenAIError as e:
        print(f"OpenAI API Error during transcription: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during transcription: {e}")
        return None

# --- Step 2: Summarize Transcription using GPT-4o ---
def summarize_text(client, text_to_summarize):
    """Generates a concise summary of the provided text using GPT-4o."""
    print("\nStep 2: Generating summary...")
    if not text_to_summarize:
        print("Error: No text provided for summarization.")
        return None

    system_prompt = "You are an expert summarizer. Create a concise summary of the following text."
    user_prompt = f"""Please provide a brief summary (1-3 sentences) of the key points in the following transcription:

Transcription:
---
{text_to_summarize}
---

Summary:
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=150,
            temperature=0.5
        )
        summary = response.choices[0].message.content
        print("Summary generation successful.")
        return summary.strip()
    except OpenAIError as e:
        print(f"OpenAI API Error during summarization: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during summarization: {e}")
        return None

# --- Step 3: (Optional) Extract Action Items using GPT-4o ---
def extract_action_items(client, text_to_analyze):
    """Identifies and extracts action items from the text using GPT-4o."""
    print("\nStep 3: Extracting action items (Optional)...")
    if not text_to_analyze:
        print("Error: No text provided for extraction.")
        return None

    system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
    user_prompt = f"""Analyze the following transcription. List any specific action items mentioned. Include who is assigned (if stated) and any deadlines (if stated). If no action items are found, state "None identified".

Transcription Text:
---
{text_to_analyze}
---

Extracted Action Items (Format as a list):
"""
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=300,
            temperature=0.1 # Low temp for factual extraction
        )
        action_items = response.choices[0].message.content
        # Check if GPT actually found items or returned "None identified" etc.
        if "none identified" in action_items.lower() and len(action_items) < 30:
             print("No specific action items identified by the model.")
             return None # Return None if no items found
        else:
             print("Action item extraction successful.")
             return action_items.strip()

    except OpenAIError as e:
        print(f"OpenAI API Error during action item extraction: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred during action item extraction: {e}")
        return None

# --- Main Execution Logic ---
if __name__ == "__main__":
    print(f"\nProcessing audio file: {audio_file_path}")

    # 1. Transcribe
    transcription = transcribe_audio(client, audio_file_path)

    if transcription:
        print(f"\n--- Full Transcription ---")
        print(transcription)
        print("-" * 26)

        # 2. Summarize
        summary = summarize_text(client, transcription)
        if summary:
            print(f"\n--- Summary ---")
            print(summary)
            print("-" * 13)

        # 3. Extract Action Items (Optional Step)
        action_items = extract_action_items(client, transcription)
        if action_items:
            print(f"\n--- Action Items ---")
            print(action_items)
            print("-" * 18)
        else:
            # This is expected if no action items were in the audio/transcription
            print("\nNo specific action items were extracted.")

        print("\n--- Processing Complete ---")

    else:
        print("\nProcessing failed due to transcription error.")

Explicación del Desglose del Código

Configuración e Inicialización:
- Importaciones: Importa las bibliotecas necesarias: os (para verificación de rutas de archivo), openai, dotenv (para la clave API), datetime, y OpenAIError.
- Clave API y Cliente: Carga la clave API de OpenAI desde un archivo .env e inicializa el objeto cliente OpenAI (client) para interacciones con la API. Incluye manejo de errores para claves faltantes o fallos de inicialización.
- Ruta del Archivo: Define la variable audio_file_path, que apunta al archivo de grabación de voz de entrada.
- Verificación de Prerrequisitos: Incluye una verificación básica usando os.path.exists() para asegurar que el archivo de audio especificado realmente existe antes de continuar.
Paso 1: Transcribir Audio (función transcribe_audio):
- Propósito: Convierte el archivo de audio de entrada en texto usando Whisper.
- Entrada: Toma el objeto client y la file_path del audio.
- Manejo de Archivos: Abre el archivo de audio en modo lectura binaria ("rb"). Incluye una verificación opcional del tamaño del archivo y advertencia sobre el límite de 25MB de Whisper.
- Llamada API: Utiliza client.audio.transcriptions.create con model="whisper-1" y response_format="text".
- Salida: Devuelve la transcripción como texto plano en forma de cadena, o None si ocurre un error.
Paso 2: Resumir Transcripción (función summarize_text):
- Propósito: Crea un resumen conciso del texto transcrito usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_summarize (la salida de Whisper).
- Ingeniería de Prompt: Construye un prompt que instruye a GPT-4o para actuar como un experto en resúmenes y proporcionar un resumen breve (1-3 oraciones) de los puntos clave de la transcripción proporcionada.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o", los prompts de sistema/usuario, y configuraciones apropiadas de max_tokens y temperature para la generación del resumen.
- Salida: Devuelve el texto del resumen generado como una cadena, o None en caso de error.
Paso 3: Extraer Elementos de Acción (función extract_action_items - Opcional):
- Propósito: Identifica y enumera tareas específicas o compromisos mencionados en la transcripción usando GPT-4o.
- Entrada: Toma el objeto client y el text_to_analyze (la transcripción).
- Ingeniería de Prompt: Utiliza un prompt específicamente diseñado para instruir a GPT-4o a encontrar elementos de acción, incluyendo la persona asignada y la fecha límite si se mencionan, y formatearlos como una lista. También pide al modelo distinguir entre tareas y sugerencias, y declarar "Ninguno identificado" si corresponde. Se usa una temperature baja (0.1) para una extracción más factual.
- Llamada API: Utiliza client.chat.completions.create con model="gpt-4o".
- Salida: Devuelve la lista de elementos de acción como una cadena. Incluye una verificación básica para devolver None si el modelo indica explícitamente que no se encontraron elementos, evitando imprimir solo "Ninguno identificado".
Ejecución Principal (if __name__ == "__main__":):
- Orquestación: Este bloque controla el flujo general.
- Llama primero a transcribe_audio.
- Si la transcripción es exitosa, procede a llamar a summarize_text.
- Luego llama a extract_action_items.
- Visualización de Salida: Imprime la transcripción completa, el resumen generado y los elementos de acción extraídos (si se encontraron) en la consola con encabezados claros.
- Manejo de Errores: Incluye verificaciones básicas para asegurar que los pasos solo se ejecuten si el paso anterior fue exitoso y proporciona mensajes si el procesamiento falla.

Este script proporciona un flujo de trabajo claro para transformar grabaciones de voz sin procesar en información estructurada y procesable utilizando el poder combinado de Whisper y GPT-4o.

Compra este libro