LangChain v1: Crea un asistente automático para resumir reuniones

LangChain es una red de código abierto frapara crear aplicaciones de IA agenticas que combinan LLM con herramientas. La versión 1.0 marca un cambio hacia un núcleo de nivel de producción con una API simplificada, límites más claros y un manejo de mensajes estandarizado entre los proveedores. 

En este tutorial, crearemos un asistente automático para resúmenes de reuniones con Streamlit que toma notas sin procesar, elabora un resumen conciso junto con las medidas a tomar y, tras la aprobación humana, añade el resumen a un documento de Google Docs. A lo largo del camino, verás en acción el nuevo flujo « create_agent », los bloques de contenido estándar y el espacio de nombres v1 más sencillo.

¿Qué es LangChain v1?

LangChain v1 es una versión reestructurada y orientada a la producción que se centra en una superficie pequeña y estable para la creación de agentes. Presenta:

• create_agent como la forma estándar de activar agentes (más limpia que los agentes precompilados heredados).

• Contenido estandarizado a través de content_blocks para que los mensajes sean coherentes entre los distintos proveedores.

• Salida estructurada y middleware para respuestas tipificadas y acciones seguras y aprobadas por personas.

• El paquete langchain se centra en los componentes básicos de los agentes, de modo que los módulos heredados se trasladan a langchain-classic, lo que facilita su detección y actualización.

En comparación con la versión v0.x, la versión v1 reduce la carga cognitiva y las peculiaridades de los proveedores al estandarizar el contenido de los mensajes y la coordinación de los agentes. Se obtiene el mismo modelo mental independientemente de si se utiliza OpenAI, Anthropic u otros.

Mejoras técnicas clave en LangChain v1

La versión original Langchain v0.x ofrecía muchos patrones para crear agentes, sin embargo, la v1 los consolida en una ruta clara utilizando un bloque « create_agent » (crear, probar, enviar) para que tus agentes sean más fáciles de razonar, probar y enviar. Incluye una herramienta más limpia, una depuración más sencilla gracias al contenido estandarizado y un bucle de agente predecible. 

A continuación, se detallan algunas de las mejoras técnicas clave que se han incorporado a esta última versión:

• create_agent flujo de trabajo: Este bucle de agente listo para la producción permite que el modelo decida cuándo llamar a las herramientas y cuándo finalizar. Por lo tanto, ya no tenéis que lidiar con múltiples patrones, lo que facilita la personalización.

• Bloques de contenido estándar: Una forma independiente del proveedor para leer mensajes es mediante el razonamiento de trazas, llamadas a herramientas, citas e incluso bits multimodales, todo ello a través de una API unificada content_blocks. Las herramientas y los registros tienen el mismo aspecto en todos los proveedores. 

• Salida estructurada: La última versión incluye compatibilidad de primera clase con esquemas tipados, por lo que puedes confiar en JSON predecible sin expresiones regulares complejas. Esto reduce los errores de análisis y las llamadas adicionales.

• Middleware: Se conectan al bucle del agente para aprobar acciones arriesgadas, resumir el historial cuando es largo y censurar la información de identificación personal antes de las llamadas.

• Espacio de nombres simplificado: El paquete langchain ahora se centra en los componentes básicos esenciales del agente, mientras que LangGraph potencia funciones de fiabilidad como la persistencia y el viaje en el tiempo bajo el capó.

Demostración: Creación de un asistente para resumir reuniones automáticamente con LangChain v1

En esta sección, implementaremos una aplicación Streamlit que automatiza los resúmenes de reuniones de principio a fin. La aplicación acepta notas de reuniones sin procesar junto con metadatos opcionales (título, fecha y asistentes). A continuación, genera un documento tipificado ( RecapDoc), que incluye el título, el resumen, las decisiones y las medidas a tomar, en un formato estructurado. Con un solo clic, el resumen aprobado (precedido por la fecha de la reunión) se adjunta a un documento de Google Docs designado.

Paso 1: Requisitos previos

Antes de crear el asistente para resúmenes automáticos de reuniones, necesitamos un conjunto mínimo de herramientas para la interfaz de usuario, el LLM, la validación tipificada y el acceso a Google Docs. Los siguientes comandos instalan todo lo necesario y configuran la clave del modelo para que tu aplicación pueda comunicarse con el proveedor.

pip install -U streamlit langchain langchain-openai pydantic python-dotenv
pip install -U google-api-python-client google-auth google-auth-oauthlib google-auth-httplib2
export OPENAI_API_KEY=...

A continuación se explica la función de cada requisito previo:

• Streamlit: Ejecuta la aplicación web localmente con una interfaz de usuario sencilla y Python.

• langchain y langchain-openai:  Proporciona la interfaz simplificada de LangChain v1 (init_chat_model, salida estructurada) y el puente del proveedor OpenAI.

• pydantic: Esta biblioteca define el esquema estricto RecapDoc para que el modelo devuelva campos tipados.

• Python-dotenv: Esto carga las variables de entorno desde un archivo .env durante el desarrollo.

• google-auth: Esto se utiliza para gestionar OAuth y la API de Google Docs, de modo que podamos añadir el resumen a un documento.

• OPENAI_API_KEY: La clave API de OpenAI autentica nuestras llamadas LLM y la configura como una variable de entorno (o utiliza un gestor de secretos).

Nota: Si utilizas otro proveedor (Anthropic, Google o un modelo local), instala la integración correspondiente de langchain-* y configura la clave API de ese proveedor.

Una vez instaladas estas dependencias y configurado OPENAI_API_KEY, el entorno estará listo. En los siguientes pasos, configuraremos la API de Google Docs a través de Google Cloud.

Paso 2: Habilitar la API de Google Docs

Para guardar cada resumen de reunión en un documento activo, la aplicación necesita permiso para escribir en Google Docs. Este paso configura el acceso de extremo a extremo. En primer lugar, nosotros:

• Obtener un archivo de cliente OAuth (credentials.json) de Google Cloud.

• A continuación, identifica el ID de documento de Google que deseas añadir.

• Por último, deja que la aplicación cree un identificador de sesión reutilizable ( token.json ) la primera vez que la ejecutes, después de que apruebes el acceso en tu navegador.

Una vez que estas tres piezas estén en su lugar, la aplicación podrá añadir resúmenes al documento de Google Docs que elijas con un solo clic. Puedes revocar o renovar el acceso en cualquier momento eliminando token.json y ejecutando la aplicación de nuevo.

Paso 2.1: Obtén credentials.json de Google Nube.

El archivo credentials.jsones la clave de tu aplicación para acceder a la API de Google Docs. Lo generas una vez en Google Cloud Console como cliente OAuth de aplicación de escritorio. Para empezar:

Crear/seleccionar un proyecto

• Abre la consola de Google Nube y selecciona Nuevo proyecto.
• Puedes asignarle un nombre según tus necesidades y, a continuación, hacer clic en Crear.

Habilita la API de Google Docs.

Ahora que ya hemos creado nuestro proyecto. Habilitemos la API necesaria para escribir en Google Docs.

• Ve a API y servicios y busca Biblioteca. También puedes utilizar la función de búsqueda.
• Busca la API de Google Docs y haz clic en Habilitar. Ten en cuenta que también deberás desactivar la API después de usarla para evitar cargos innecesarios.

Configura la pantalla de consentimiento de OAuth.

Una vez habilitada la API, lo siguiente que hay que hacer es configurar la autenticación para tu correo electrónico preferido.

• Ve a API y servicios y haz clic en Pantalla de consentimiento de OAuth.
• Selecciona Externo y rellena la información básica de la aplicación.
• En la sección Audiencia/Usuarios de prueba , haz clic en Añadir usuarios y añade las cuentas de Gmail que vas a utilizar antes de pulsar Guardar.
• Dejar la aplicación en modo de prueba está bien para el desarrollo.

Crear credenciales de cliente OAuth

El último paso es generar y descargar el archivo credentials.json. Para esto:

• Ve a API y servicios y haz clic en Credenciales.

• Haz clic en « + CREATE CREDENTIALS » (Aplicaciones y servicios) y accederás al ID de cliente OAuth.

• Bajo Aplicación tipo selecciona Escritorio y haz clic en y haz clic en Crear.

• La generación del ID de cliente y la clave secreta, junto con un archivo JSON descargable, puede tardar hasta 5 minutos.

• Guarda el archivo JSON como credentials.json en la misma carpeta que tu app.py (o proporciona su ruta en la configuración de tu aplicación).

Ahora tienes un cliente OAuth de escritorio que la aplicación puede utilizar para iniciar un inicio de sesión basado en el navegador y solicitar permiso para acceder a Google Docs en tu nombre.

Paso 2.2: ID de documento de Google

La aplicación necesita saber a qué documento añadirlo. Ese documento se identifica mediante un identificador único integrado en la URL. Para este paso,

• Abre el documento de Google Docs deseado en un navegador.

• Copia la cadena de la URL entre /d/ y /edit, por ejemplo: https://docs.google.com/document/d//edit

• Pega esto ID del documento en el campo «Google Doc ID» de la aplicación (o en la variable de configuración correspondiente).

Con el ID de documento correcto, la aplicación escribirá resúmenes en el documento exacto que hayas seleccionado.

Paso 2.3: Token.json

En el primer apéndice, la aplicación necesita tu aprobación explícita para acceder al documento. Una vez que hayas dado tu aprobación, Google devuelve un token que la aplicación almacena localmente como token.json. Así es como se genera este archivo:

• Ejecuta la aplicación y haz clic en Añadir a Google Doc.

• Se abrirá una ventana del navegador en la que se te pedirá que inicies sesión con uno de los usuarios de prueba que has añadido en el paso anterior y que apruebes el ámbito.

• Después de confirmar, la aplicación escribe token.json junto a tu código. Este archivo contiene tus tokens de acceso/actualización reutilizables.

Nota: Si alguna vez necesitas cambiar de cuenta o volver a ejecutar el consentimiento, simplemente elimina token.json y haz clic en Añadir a Google Doc de nuevo.

Paso 3: Importaciones 

Antes de escribir cualquier lógica, importamos los módulos que alimentan la interfaz de usuario, los contratos de datos tipados, las llamadas al modelo y la integración con Google Docs. Agrupar las importaciones por finalidad mantiene la legibilidad del código base y deja claro qué capa hay que revisar cuando algo falla.

import os
import io
import json
from datetime import date
from typing import List, Optional
import streamlit as st
from pydantic import BaseModel, Field
from dotenv import load_dotenv
# ---- LangChain v1 surface ----
from langchain.agents import create_agent
from langchain.messages import SystemMessage, HumanMessage
from langchain.chat_models import init_chat_model
# ---- Google Docs API ----
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

Para este paso, importamos solo lo que necesita la aplicación, es decir, utilidades estándar como os, io, json, date y sugerencias de escritura para rutas, búferes y serialización ligera. A continuación, importamos Streamlit para la interfaz de usuario, Pydantic para los esquemas tipados RecapDoc y dotenv para cargar las variables de entorno. La superficie LangChain v1 init_chat_model y create_agent para inicializar un modelo de chat independiente del proveedor y estructurar las indicaciones y, por último, las piezasde la API de Google Docs que gestionan OAuth y nos proporcionan un cliente autenticado para añadir resúmenes al documento elegido.

Paso 4: Definir salida estructurada

Para que la respuesta del modelo sea fiable y fácil de usar, definimos un contrato tipado para el resumen. El uso de modelos Pydantic garantiza que el LLM devuelva campos predecibles que nuestra interfaz de usuario pueda representar, la API pueda almacenar y las automatizaciones puedan validar.

class ActionItem(BaseModel):
    owner: str = Field(..., description="Person responsible")
    task: str = Field(..., description="Short, specific task")
    due_date: str = Field(..., description="ISO date (YYYY-MM-DD) or natural language like 'next Friday'")
class RecapDoc(BaseModel):
    title: str
    date: str
    attendees: List[str]
    summary: str
    decisions: List[str]
    action_items: List[ActionItem]

Estos son los componentes clave del bloque de código anterior:

• ActionItem clase: Captura los elementos esenciales de una tarea de seguimiento como owner, task y due_date con descripciones breves y explícitas para que el modelo las complete correctamente. Permitir fechas ISO o frases naturales mantiene la flexibilidad de la entrada sin dejar de ser analizable en fases posteriores.

• RecapDoc clase: Esta clase representa el resumen completo como un único objeto, incluyendo title, date, attendees, un summary conciso, un decisions explícito y una lista de action_items.

Con LangChain v1, puedes solicitar este esquema directamente a través de with_structured_output(RecapDoc), lo que reduce el frágil análisis de cadenas, mejora la validación y te permite detectar rápidamente los errores cuando faltan campos.

Paso 5: Mensaje del sistema 

El sistema establece las reglas básicas para tu asistente. Le indica al modelo exactamente qué producir, qué evitar y cómo estructurar su salida para que los pasos posteriores funcionen de manera fiable en todo momento.

SYSTEM_PROMPT = """You are a precise assistant that produces concise, high-signal meeting recaps.
Return a structured RecapDoc with:
- title, date, attendees
- a brief summary (3–6 sentences)
- explicit decisions (bullet-style)
- action_items (each has owner, task, due_date)
Rules:
- Only include info supported by the notes or explicit user inputs.
- Keep action items specific with clear owners and due dates.
- If something is unknown, say "Unknown" rather than inventing details.
"""

El sistema hace que el asistente sea preciso y conciso, centrándose en resúmenes de alta calidad en lugar de transcripciones. Imprime un esquema claro que incluye el título, la fecha, los asistentes, el resumen, las decisiones y las medidas a tomar, con reglas como un resumen de entre 3 y 6 frases, decisiones en forma de lista y medidas a tomar con responsable, tarea y fecha de vencimiento.

Con una indicación clara del sistema, el modelo produce de forma sistemática resúmenes útiles y estructurados a la primera. 

Paso 6: Asistente de Google OAuth

En este paso, definimos una función auxiliar que establece una conexión fiable y reutilizable con Google Docs para que la aplicación pueda añadir resúmenes al documento elegido. Solo solicita el ámbito Docs y gestiona el consentimiento inicial, la actualización de tokens y la construcción del servicio.

SCOPES = ["https://www.googleapis.com/auth/documents"]  
def get_google_docs_service(
    credentials_path: Optional[str],
    token_path: str = "token.json",
    use_secrets: bool = False
):
    creds = None
    if use_secrets:
        try:
            if "google_credentials_json" in st.secrets:
                with open("credentials_temp.json", "w") as f:
                    f.write(st.secrets["google_credentials_json"])
                credentials_path = "credentials_temp.json"
        except Exception:
            pass
    if os.path.exists(token_path):
        creds = Credentials.from_authorized_user_file(token_path, SCOPES)
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            try:
                creds.refresh(Request())  
            except Exception:
                pass
        if not creds or not creds.valid:
            if not credentials_path or not os.path.exists(credentials_path):
                raise RuntimeError(
                    "Missing Google OAuth credentials. Provide 'credentials.json' "
                    "or set st.secrets['google_credentials_json']."
                )
            flow = InstalledAppFlow.from_client_secrets_file(credentials_path, SCOPES)
            creds = flow.run_local_server(port=0)
            with open(token_path, "w") as token:
                token.write(creds.to_json())
    return build("docs", "v1", credentials=creds)

La función get_google_docs_service()gestiona OAuth y la creación de servicios mediante:

• Acceso al ámbito: La función anterior utiliza la función predefinida SCOPESpara limitar los permisos a Google Docs.

• Cargando credenciales: Lee desde un archivo local credentials.json o desde st.secrets["google_credentials_json"] ,que es el contenedor de secretos de Streamlit cuando use_secrets=True.

• Reutilización de tokens: Si existe token.json, el código lo carga y, si el token ha caducado, lo actualiza silenciosamente.

• Consentimiento inicial: Si no se encuentra ningún token válido, se inicia el escritorio InstalledAppFlow, que solicita al usuario que se autentique en el navegador y, a continuación, guarda token.json para futuras ejecuciones.

• Devolución de un cliente: Por último, creamos y devolvemos un cliente Docs autenticado mediante la función ` build()`.

Una vez configurado, puedes reutilizar el mismo token de acceso de duración limitada ( token.json ) para la autenticación o actualizar el token automáticamente. Para restablecer el acceso, simplemente elimina token.json y vuelve a ejecutar la aplicación.

Paso 7: Utilidad Append y renderizador Markdown

RecapDoc A continuación, convertimos un documento de Google Docs escrito en Markdown limpio que se añade al documento de Google Docs de destino. Una función genera el resumen, mientras que la otra realiza la escritura autenticada al final del documento.

def append_plaintext_to_doc(docs_service, document_id: str, text: str):
    doc = docs_service.documents().get(documentId=document_id).execute()
    end_index = doc.get("body", {}).get("content", [])[-1]["endIndex"]
    requests = [
        {
            "insertText": {
                "location": {"index": end_index - 1},
                "text": text + "\n"
            }
        }
    ]
    return docs_service.documents().batchUpdate(
        documentId=document_id,
        body={"requests": requests}
    ).execute()
def recap_to_markdown(recap: RecapDoc) -> str:
    lines = [
        f"# {recap.title} — {recap.date}",
        "",
        f"**Attendees:** {', '.join(recap.attendees) if recap.attendees else 'Unknown'}",
        "",
        "## Summary",
        recap.summary.strip(),
        "",
        "## Decisions",
    ]
    if recap.decisions:
        for d in recap.decisions:
            lines.append(f"- {d}")
    else:
        lines.append("- None recorded")
    lines.append("")
    lines.append("## Action Items")
    if recap.action_items:
        for ai in recap.action_items:
            lines.append(f"- **{ai.owner}** — {ai.task} _(Due: {ai.due_date})_")
    else:
        lines.append("- None recorded")
    return "\n".join(lines)

Los dos ayudantes anteriores trabajan juntos de la siguiente manera:

• La función « recap_to_markdown() » crea un resumen legible. Incluye un título con la fecha, los asistentes, un resumen conciso y las medidas a tomar con el responsable, la tarea y la fecha de vencimiento. También vuelve a «Desconocido» o «Sin registrar» cuando faltan campos.

• Mientras que la función « append_plaintext_to_doc() » recupera el documento, encuentra el índice final actual y envía una única solicitud « insertText » a través de « documents() ». El texto se añade con una nueva línea al final, de modo que las entradas siguientes comienzan en una nueva línea.

Nota: Para documentos vacíos, considera establecer el índice de inserción por defecto en 1 si no está disponible endIndex.

Con la representación y el apéndice de Markdown en su lugar, a continuación configuramos nuestro generador de resúmenes.

Paso 8: Generador de resúmenes 

Esta función es el núcleo de la aplicación. Toma notas sin procesar y metadatos opcionales, llama a un modelo de chat y devuelve un objeto tipado RecapDoc para que todo lo que viene después siga siendo predecible.

def generate_recap(model_name: str, notes: str, title: str, date_str: str, attendees_csv: str) -> RecapDoc:
    model = init_chat_model(model=model_name)
    structured_llm = model.with_structured_output(RecapDoc)
    attendees_hint = [a.strip() for a in attendees_csv.split(",")] if attendees_csv.strip() else []
    user_prompt = (
        "You will receive meeting notes and metadata.\n\n"
        f"Title: {title or 'Unknown'}\n"
        f"Date: {date_str or 'Unknown'}\n"
        f"Attendees: {attendees_hint if attendees_hint else 'Unknown'}\n\n"
        "Notes:\n"
        f"{notes.strip()}\n"
    )
    messages = [
        SystemMessage(content=SYSTEM_PROMPT),
        HumanMessage(content=user_prompt)
    ] 
    try:
        recap = structured_llm.invoke(messages)
    except Exception as e:
        st.error(f"Error generating recap: {e}")
        recap = RecapDoc(
            title=title or "Unknown",
            date=date_str or "Unknown",
            attendees=attendees_hint or [],
            summary=f"Error generating summary: {str(e)}",
            decisions=[],
            action_items=[]
        )  
    return recap

El generador de resúmenes incluye tres componentes clave:

• Inicialización del modelo: La función init_chat_model() crea un modelo de chat para el proveedor que hayas elegido. A continuación, llamamos a la función ` with_structured_output() ` para indicar al modelo exactamente qué forma debe devolver. Genera un objeto Python que coincide con los campos RecapDoc.

• Montaje rápido: Normalizamos las entradas y enviamos dos mensajes, incluyendo un « SystemMessage » con reglas estrictas (el aviso del sistema) y un « HumanMessage » con el título, la fecha, los asistentes y las notas sin procesar.

• Generación estructurada: La función structured_llm.invoke() devuelve un RecapDoc validado, evitando el análisis sintáctico y reduciendo las alucinaciones.

Al dirigir tu modelo GPT a través del envoltorio de salida estructurada de LangChain, el paso de recapitulación se vuelve fiable y está listo para la representación Markdown sin cambiar ninguna lógica posterior.

Paso 9: Interfaz de usuario Streamlit

Este paso conecta toda la demostración en una aplicación Streamlit de una sola página. El usuario pega notas, añade metadatos opcionales, genera un resumen estructurado, lo previsualiza como Markdown y lo añade a un documento de Google Docs con un solo clic.

def main():
    load_dotenv()
    st.set_page_config(page_title="Meeting Recap Assistant (LangChain v1)", page_icon=" ", layout="wide")
    st.markdown("<h1 style='text-align: center;'>Meeting Recap Assistant With LangChain v1</h1>", unsafe_allow_html=True)
    model_name = os.getenv("LC_MODEL", "gpt-4o-mini")
    document_id = "10G1k8-2JG_phkpjWM3xZEy2wNg5trUO0SJ2WN7kR3po"
    cred_mode = "credentials.json file"
    credentials_path = os.getenv("GOOGLE_CREDENTIALS_JSON", "credentials.json")
    st.subheader(" Add your meeting notes")
    colL, colR = st.columns([2, 1])
    with colL:
        notes = st.text_area(" ", height=300, placeholder="Paste your raw notes here...")
    with colR:
        title = st.text_input("Meeting Title", value="")
        date_str = st.date_input("Meeting Date", value=date.today())
        attendees_csv = st.text_input("Attendees (comma-separated)", value="")
    if "recap" not in st.session_state:
        st.session_state.recap = None
    if "markdown_text" not in st.session_state:
        st.session_state.markdown_text = None
    col1, col2, col3 = st.columns([1, 1, 2])    
    with col1:
        generate_btn = st.button("Generate Recap")    
    with col2:
        append_btn = st.button("Append to Google Doc", disabled=(st.session_state.recap is None))    
    if generate_btn:
        if not notes.strip():
            st.error("Please paste some notes.")
            st.stop()
        try:
            recap = generate_recap(
                model_name=model_name,
                notes=notes,
                title=title,
                date_str=str(date_str),
                attendees_csv=attendees_csv,
            )
            st.session_state.recap = recap
            st.session_state.markdown_text = recap_to_markdown(recap)
            st.rerun()
        except Exception as e:
            st.exception(e)
            st.stop()
    if append_btn and st.session_state.recap is not None:
        try:
            use_secrets = (cred_mode == "Streamlit secrets")
            service = get_google_docs_service(
                credentials_path=credentials_path if cred_mode == "credentials.json file" else None,
                use_secrets=use_secrets
            )
            final_text = f"\n\n===== {st.session_state.recap.title} — {st.session_state.recap.date} =====\n\n" + st.session_state.markdown_text
            append_plaintext_to_doc(service, document_id, final_text)
            st.success("Recap appended to the Google Doc")
        except Exception as e:
            st.exception(e)

    if st.session_state.recap is not None:
        st.markdown("---")
        st.markdown(st.session_state.markdown_text)
if __name__ == "__main__":
    main()

La aplicación Streamlit conecta una única acción «Generate Recap» al modelo y la expone a una interfaz de usuario web local, utilizando:

• Entradas (columnas izquierda/derecha): El panel izquierdo es un gran espacio en blanco ( st.text_area ) para notas sin formato. Mientras que el panel derecho muestra el título, la fecha y los asistentes.

• Resultados (área de vista previa): Cuando hay un resumen, la aplicación muestra un separador y una vista previa en Markdown del resumen estructurado para que puedas revisarlo rápidamente.

• Cableado de la interfaz (acciones): Estas acciones constituyen el componente central de nuestra aplicación. Incluye:

• Generar resumen: Valida las notas, llama a la función generate_recap(), que las convierte a Markdown, y a st.rerun() para actualizarlas.

• Añadir a Google Doc: A continuación, creamos un cliente autenticado con get_google_docs_service(), que añade un encabezado con fecha y lo adjunta al documento de destino.

• Estado: El método ` st.session_state ` almacena los últimos valores de ` RecapDoc ` y ` markdown_text ` para que la interfaz de usuario se mantenga estable entre las distintas ejecuciones.

• Configuración de la aplicación: Por último, el método load_dotenv() lee las variables de entorno, mientras que st.set_page_config() establece el diseño y las rutas de las credenciales procedentes del entorno o de los valores predeterminados.

Guarda como « app.py » y ejecuta el siguiente comando en el terminal. 

streamlit run app.py

Ahora tienes una herramienta completa para resumir reuniones que tiene este aspecto: