modules/discourse/discourse_live_interface.py

```python
# modules/discourse/discourse/discourse_live_interface.py

import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
import pandas as pd
import logging

# Configuración del logger
logger = logging.getLogger(__name__)

# Importaciones locales
from .discourse_process import perform_discourse_analysis
from ..utils.widget_utils import generate_unique_key
from ..database.discourse_mongo_db import store_student_discourse_result
from ..database.chat_mongo_db import store_chat_history, get_chat_history

def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
    """
    Interfaz para el análisis del discurso en vivo
    """
    try:
        # 1. Inicializar el estado de la sesión
        if 'discourse_live_state' not in st.session_state:
            st.session_state.discourse_live_state = {
                'analysis_count': 0,
                'current_text1': '',
                'current_text2': '',
                'last_result': None,
                'text_changed': False
            }

        # 2. Función para manejar cambios en los textos
        def on_text1_change():
            current_text = st.session_state.discourse_live_text1
            st.session_state.discourse_live_state['current_text1'] = current_text
            st.session_state.discourse_live_state['text_changed'] = True

        def on_text2_change():
            current_text = st.session_state.discourse_live_text2
            st.session_state.discourse_live_state['current_text2'] = current_text
            st.session_state.discourse_live_state['text_changed'] = True

        # 3. Crear columnas con proporción 1:3
        input_col, result_col = st.columns([1, 3])

        # Columna izquierda: Entrada de textos
        with input_col:
            st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
            
            # Primer área de texto
            st.markdown("**Texto 1 (Patrón)**")
            text_input1 = st.text_area(
                "Texto 1",
                height=250,
                key="discourse_live_text1",
                value=st.session_state.discourse_live_state.get('current_text1', ''),
                on_change=on_text1_change,
                label_visibility="collapsed"
            )

            # Segundo área de texto
            st.markdown("**Texto 2 (Comparación)**")
            text_input2 = st.text_area(
                "Texto 2",
                height=250,
                key="discourse_live_text2",
                value=st.session_state.discourse_live_state.get('current_text2', ''),
                on_change=on_text2_change,
                label_visibility="collapsed"
            )

            # Botón de análisis
            analyze_button = st.button(
                discourse_t.get('analyze_button', 'Analizar'),
                key="discourse_live_analyze",
                type="primary",
                icon="🔍",
                disabled=not (text_input1 and text_input2),
                use_container_width=True
            )

            if analyze_button and text_input1 and text_input2:
                try:
                    with st.spinner(discourse_t.get('processing', 'Procesando...')):
                        # Realizar análisis
                        result = perform_discourse_analysis(
                            text_input1,
                            text_input2,
                            nlp_models[lang_code],
                            lang_code
                        )

                        if result['success']:
                            st.session_state.discourse_live_state['last_result'] = result
                            st.session_state.discourse_live_state['analysis_count'] += 1
                            st.session_state.discourse_live_state['text_changed'] = False
                            
                            # Guardar en base de datos
                            store_student_discourse_result(
                                st.session_state.username,
                                text_input1,
                                text_input2,
                                result
                            )
                        else:
                            st.error(result.get('message', 'Error en el análisis'))

                except Exception as e:
                    logger.error(f"Error en análisis: {str(e)}")
                    st.error(discourse_t.get('error_processing', 'Error al procesar el texto'))

        # Columna derecha: Visualización de resultados
        with result_col:
            st.subheader(discourse_t.get('live_results', 'Resultados en vivo'))

            if 'last_result' in st.session_state.discourse_live_state and \
               st.session_state.discourse_live_state['last_result'] is not None:
                
                # Mostrar resultados usando la misma función que el análisis normal
                display_discourse_results(
                    st.session_state.discourse_live_state['last_result'],
                    lang_code,
                    discourse_t
                )

            elif st.session_state.discourse_live_state.get('text_changed', False):
                st.info(discourse_t.get('changes_pending', 
                    'Los textos han cambiado. Presione Analizar para ver los nuevos resultados.'))
            else:
                st.info(discourse_t.get('initial_message', 
                    'Ingrese los textos y presione Analizar para ver los resultados.'))

    except Exception as e:
        logger.error(f"Error general en interfaz del discurso en vivo: {str(e)}")
        st.error(discourse_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
```