Claude Code

app.py

@@ -1,35 +1,317 @@
-# app.py
 import gradio as gr
-import sys
-from pathlib import Path
-sys.path.append(str(Path(__file__).parent / "src"))
-from src.IberleyAI.Tools.IberleyIAPrompt import IberleyIAPrompt
-
-# Función "wrapper" que llama al método de la tool
-def run_iberley(prompt: str) -> str:
-    # Aquí usamos el método de la clase
-    return IberleyIAPrompt.iberley_ia_prompt(prompt)
-
-# --------------------------
-# Interfaz Gradio
-# --------------------------
-with gr.Blocks() as demo:
-    gr.Markdown("## IberleyAI Connector")
-
-    # Entrada del usuario
-    prompt_input = gr.Textbox(
-        placeholder="Escribe algo...",
-        lines=1,
-        label="Tu prompt"
-    )
-    # Salida del modelo
-    response_output = gr.Textbox(
-        lines=10,
-        label="Respuesta de IberleyAI"
-    )
-
-    # Conectar la entrada con la función
-    prompt_input.submit(fn=run_iberley, inputs=prompt_input, outputs=response_output)
-
-# Lanzar la app con soporte MCP
-demo.launch(mcp_server=True)
+import json
+import requests
+from typing import Dict, Any, List
+import datetime
+
+class IberleyLegalAI:
+    """
+    Clase principal para el sistema de IA Legal de Iberley
+    """
+    
+    def __init__(self):
+        self.name = "IberleyIA"
+        self.description = "Sistema de IA Legal para Iberley Informacion Legal SL"
+        self.version = "1.0.0"
+    
+    def analyze_legal_document(self, document_text: str, analysis_type: str = "general") -> Dict[str, Any]:
+        """
+        Analiza documentos legales y devuelve un análisis estructurado
+        """
+        # Aquí iría vuestra lógica de análisis legal
+        result = {
+            "document_summary": f"Análisis {analysis_type} del documento",
+            "key_points": [
+                "Punto legal clave 1",
+                "Punto legal clave 2", 
+                "Punto legal clave 3"
+            ],
+            "recommendations": [
+                "Recomendación 1",
+                "Recomendación 2"
+            ],
+            "risk_assessment": "Bajo/Medio/Alto",
+            "timestamp": datetime.datetime.now().isoformat(),
+            "processed_by": "IberleyIA"
+        }
+        return result
+    
+    def search_legal_precedents(self, query: str, jurisdiction: str = "España") -> List[Dict]:
+        """
+        Busca precedentes legales relevantes
+        """
+        # Aquí iría vuestra lógica de búsqueda de precedentes
+        precedents = [
+            {
+                "case_name": "Caso relevante 1",
+                "court": "Tribunal Supremo",
+                "date": "2023-01-15",
+                "relevance_score": 0.95,
+                "summary": "Resumen del precedente relevante"
+            }
+        ]
+        return precedents
+    
+    def generate_legal_draft(self, document_type: str, parameters: Dict[str, Any]) -> str:
+        """
+        Genera borradores de documentos legales
+        """
+        # Aquí iría vuestra lógica de generación de documentos
+        draft = f"""
+        BORRADOR DE {document_type.upper()}
+        
+        Generado por IberleyIA
+        Fecha: {datetime.datetime.now().strftime('%d/%m/%Y')}
+        
+        [Contenido del documento basado en los parámetros proporcionados]
+        
+        NOTA: Este es un borrador generado por IA. 
+        Requiere revisión legal profesional antes de su uso.
+        """
+        return draft.strip()
+
+# Inicializar el sistema
+iberley_ai = IberleyLegalAI()
+
+def create_gradio_interface():
+    """
+    Crea la interfaz Gradio optimizada para uso con Claude
+    """
+    
+    # Función wrapper para análisis de documentos
+    def analyze_document_wrapper(document_text, analysis_type):
+        if not document_text.strip():
+            return "❌ Error: Debe proporcionar un documento para analizar"
+        
+        try:
+            result = iberley_ai.analyze_legal_document(document_text, analysis_type)
+            return f"""
+# 📋 Análisis Completado
+
+## Resumen
+{result['document_summary']}
+
+## Puntos Clave
+{chr(10).join([f"• {point}" for point in result['key_points']])}
+
+## Recomendaciones
+{chr(10).join([f"• {rec}" for rec in result['recommendations']])}
+
+## Evaluación de Riesgo
+**{result['risk_assessment']}**
+
+---
+*Procesado el {result['timestamp']} por {result['processed_by']}*
+            """
+        except Exception as e:
+            return f"❌ Error en el análisis: {str(e)}"
+    
+    # Función wrapper para búsqueda de precedentes
+    def search_precedents_wrapper(query, jurisdiction):
+        if not query.strip():
+            return "❌ Error: Debe proporcionar una consulta de búsqueda"
+        
+        try:
+            precedents = iberley_ai.search_legal_precedents(query, jurisdiction)
+            if not precedents:
+                return "ℹ️ No se encontraron precedentes relevantes para esta consulta"
+            
+            result = "# 🔍 Precedentes Encontrados\n\n"
+            for prec in precedents:
+                result += f"""
+## {prec['case_name']}
+- **Tribunal**: {prec['court']}
+- **Fecha**: {prec['date']}
+- **Relevancia**: {prec['relevance_score']:.0%}
+- **Resumen**: {prec['summary']}
+
+---
+                """
+            return result
+        except Exception as e:
+            return f"❌ Error en la búsqueda: {str(e)}"
+    
+    # Función wrapper para generación de documentos
+    def generate_draft_wrapper(document_type, client_name, subject, additional_params):
+        if not document_type or not client_name:
+            return "❌ Error: Debe especificar el tipo de documento y el nombre del cliente"
+        
+        parameters = {
+            "client_name": client_name,
+            "subject": subject,
+            "additional_params": additional_params
+        }
+        
+        try:
+            draft = iberley_ai.generate_legal_draft(document_type, parameters)
+            return draft
+        except Exception as e:
+            return f"❌ Error en la generación: {str(e)}"
+    
+    # Crear la interfaz con múltiples pestañas
+    with gr.Blocks(
+        title="IberleyIA - Sistema de IA Legal",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        .tab-nav {
+            background-color: #f8f9fa;
+        }
+        """
+    ) as demo:
+        
+        # Cabecera principal
+        gr.Markdown("""
+        # 🏛️ IberleyIA - Sistema de IA Legal
+        
+        **Iberley Informacion Legal SL** | Sistema inteligente de análisis legal
+        
+        > 💡 **Para Claude**: Puedes usar esta interfaz para ayudar con análisis legales, búsqueda de precedentes y generación de documentos legales. Cada pestaña ofrece funcionalidades específicas.
+        """)
+        
+        # Pestañas principales
+        with gr.Tabs():
+            
+            # Pestaña 1: Análisis de Documentos
+            with gr.TabItem("📄 Análisis de Documentos", id="analyze"):
+                gr.Markdown("### Analiza documentos legales y obtén insights detallados")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        doc_input = gr.Textbox(
+                            label="Documento a Analizar",
+                            placeholder="Pega aquí el texto del documento legal que deseas analizar...",
+                            lines=10,
+                            max_lines=20
+                        )
+                        analysis_type = gr.Dropdown(
+                            label="Tipo de Análisis",
+                            choices=["general", "contractual", "penal", "laboral", "mercantil", "civil"],
+                            value="general"
+                        )
+                        analyze_btn = gr.Button("🔍 Analizar Documento", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        analysis_output = gr.Markdown(
+                            label="Resultado del Análisis",
+                            value="*El análisis aparecerá aquí...*"
+                        )
+                
+                analyze_btn.click(
+                    fn=analyze_document_wrapper,
+                    inputs=[doc_input, analysis_type],
+                    outputs=analysis_output
+                )
+            
+            # Pestaña 2: Búsqueda de Precedentes
+            with gr.TabItem("🔎 Precedentes Legales", id="search"):
+                gr.Markdown("### Busca precedentes legales relevantes")
+                
+                with gr.Row():
+                    with gr.Column():
+                        search_query = gr.Textbox(
+                            label="Consulta de Búsqueda",
+                            placeholder="Ej: responsabilidad civil por daños, contratos laborales temporales...",
+                            lines=3
+                        )
+                        jurisdiction = gr.Dropdown(
+                            label="Jurisdicción",
+                            choices=["España", "Unión Europea", "Internacional"],
+                            value="España"
+                        )
+                        search_btn = gr.Button("🔍 Buscar Precedentes", variant="primary")
+                    
+                    with gr.Column():
+                        precedents_output = gr.Markdown(
+                            value="*Los precedentes encontrados aparecerán aquí...*"
+                        )
+                
+                search_btn.click(
+                    fn=search_precedents_wrapper,
+                    inputs=[search_query, jurisdiction],
+                    outputs=precedents_output
+                )
+            
+            # Pestaña 3: Generación de Documentos
+            with gr.TabItem("📝 Generador de Documentos", id="generate"):
+                gr.Markdown("### Genera borradores de documentos legales")
+                
+                with gr.Row():
+                    with gr.Column():
+                        doc_type = gr.Dropdown(
+                            label="Tipo de Documento",
+                            choices=[
+                                "Contrato de Arrendamiento",
+                                "Contrato Laboral",
+                                "Carta de Reclamación",
+                                "Acuerdo de Confidencialidad",
+                                "Poder Notarial",
+                                "Demanda Civil",
+                                "Recurso de Apelación"
+                            ],
+                            value="Contrato de Arrendamiento"
+                        )
+                        client_name = gr.Textbox(
+                            label="Nombre del Cliente/Parte",
+                            placeholder="Nombre completo o razón social"
+                        )
+                        subject = gr.Textbox(
+                            label="Asunto/Objeto",
+                            placeholder="Breve descripción del asunto",
+                            lines=2
+                        )
+                        additional_params = gr.Textbox(
+                            label="Parámetros Adicionales",
+                            placeholder="Información adicional específica para el documento...",
+                            lines=4
+                        )
+                        generate_btn = gr.Button("📝 Generar Borrador", variant="primary")
+                    
+                    with gr.Column():
+                        draft_output = gr.Textbox(
+                            label="Borrador Generado",
+                            lines=20,
+                            max_lines=30,
+                            show_copy_button=True
+                        )
+                
+                generate_btn.click(
+                    fn=generate_draft_wrapper,
+                    inputs=[doc_type, client_name, subject, additional_params],
+                    outputs=draft_output
+                )
+        
+        # Footer con información
+        gr.Markdown("""
+        ---
+        
+        ### 🤖 Instrucciones para Claude:
+        
+        1. **Análisis de Documentos**: Usa esta función para analizar contratos, demandas, o cualquier documento legal
+        2. **Búsqueda de Precedentes**: Encuentra casos similares y jurisprudencia relevante
+        3. **Generación de Documentos**: Crea borradores iniciales de documentos legales
+        
+        ### ⚖️ Aviso Legal:
+        Este sistema genera contenido de apoyo para profesionales legales. Todo output debe ser revisado por un abogado cualificado antes de su uso oficial.
+        
+        **Iberley Informacion Legal SL** | [www.iberley.es](https://www.iberley.es)
+        """)
+    
+    return demo
+
+# Crear y configurar la aplicación
+if __name__ == "__main__":
+    app = create_gradio_interface()
+    
+    # Configuración para producción en Hugging Face Spaces
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,  # False para Spaces, True para desarrollo local
+        show_error=True,
+        show_tips=False,
+        enable_queue=True,
+        max_threads=40
+    )

readme_space.md

@@ -0,0 +1,40 @@
+---
+title: IberleyIA
+emoji: ⚖️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Sistema de IA Legal para Iberley Informacion Legal SL
+---
+
+# 🏛️ IberleyIA - Sistema de IA Legal
+
+Sistema inteligente de análisis legal desarrollado por **Iberley Informacion Legal SL**.
+
+## 🚀 Características
+
+- **Análisis de Documentos Legales**: Analiza contratos, demandas y documentos legales
+- **Búsqueda de Precedentes**: Encuentra jurisprudencia y casos relevantes
+- **Generación de Documentos**: Crea borradores de documentos legales
+
+## 🤖 Compatible con Claude
+
+Esta aplicación está optimizada para trabajar con Claude AI. Puede ser usada directamente desde la interfaz web o mediante enlaces compartidos.
+
+## 🔧 Uso con Claude
+
+1. Comparte este enlace con Claude: `https://iberley-iberleyia.hf.space`
+2. Claude puede interactuar directamente con las diferentes funcionalidades
+3. Los resultados se muestran en formato estructurado y legible
+
+## ⚖️ Aviso Legal
+
+Este sistema genera contenido de apoyo para profesionales legales. Todo output debe ser revisado por un abogado cualificado antes de su uso oficial.
+
+---
+
+**Iberley Informacion Legal SL** | [www.iberley.es](https://www.iberley.es)

requirements_txt.txt

@@ -0,0 +1,8 @@
+gradio>=4.0.0
+requests>=2.31.0
+python-dateutil>=2.8.2
+pandas>=2.0.0
+numpy>=1.24.0
+transformers>=4.30.0
+torch>=2.0.0
+# Añadir aquí cualquier librería específica que uséis para vuestro análisis legal