El Futuro de RAG en 2025-2026: Hybrid Search, Multi-Modal y Agentes Autónomos IA

"""
RAG Evaluation con Ragas framework.
Mide faithfulness, answer relevance, context precision/recall.
Requirements: pip install ragas datasets langchain-openai
"""

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision,
    context_recall
)
from datasets import Dataset
import pandas as pd
from typing import List, Dict


def evaluate_rag_system(
    questions: List[str],
    answers: List[str],
    contexts: List[List[str]],  # List of lists (docs por query)
    ground_truths: List[str]  # Ground truth answers
) -> Dict[str, float]:
    """
    Evalúa RAG system con Ragas metrics.
    
    Args:
        questions: User queries
        answers: Generated answers
        contexts: Retrieved contexts (docs) por query
        ground_truths: Expected answers (para context_recall)
    
    Returns:
        Dict con scores por métrica
    """
    # Construir dataset
    data = {
        "question": questions,
        "answer": answers,
        "contexts": contexts,
        "ground_truth": ground_truths
    }
    dataset = Dataset.from_dict(data)

    # Run evaluation con 4 métricas principales
    result = evaluate(
        dataset,
        metrics=[
            faithfulness,         # Answer basado en context (0-1)
            answer_relevancy,     # Answer relevante a query (0-1)
            context_precision,    # Relevant docs en top positions (0-1)
            context_recall        # Context contiene info necesaria (0-1)
        ]
    )

    return result


# ============================================================
# EJEMPLO USO
# ============================================================

if __name__ == "__main__":
    # Sample evaluation dataset (en producción, 50-200 queries)
    questions = [
        "What is the capital of France?",
        "How do I deploy NextJS on Vercel?",
        "What are the symptoms of diabetes?"
    ]

    # Generated answers (from your RAG system)
    answers = [
        "The capital of France is Paris, known for the Eiffel Tower.",
        "Deploy NextJS on Vercel using 'vercel deploy' command or GitHub integration.",
        "Common symptoms include increased thirst, frequent urination, and fatigue."
    ]

    # Retrieved contexts (documents returned by retriever)
    contexts = [
        [
            "Paris is the capital and most populous city of France.",
            "The Eiffel Tower is a landmark in Paris."
        ],
        [
            "Vercel is the deployment platform for NextJS. Use 'vercel deploy' or connect GitHub repo.",
            "NextJS supports serverless functions out of the box."
        ],
        [
            "Diabetes symptoms: increased thirst, frequent urination, extreme hunger, fatigue, blurred vision.",
            "Type 2 diabetes is the most common form."
        ]
    ]

    # Ground truth answers (para context_recall metric)
    ground_truths = [
        "Paris",
        "Use vercel deploy command or GitHub integration",
        "Increased thirst, frequent urination, fatigue, blurred vision"
    ]

    # Evaluate
    results = evaluate_rag_system(
        questions=questions,
        answers=answers,
        contexts=contexts,
        ground_truths=ground_truths
    )

    # Print results
    print("\n" + "="*60)
    print("RAG EVALUATION RESULTS (Ragas Metrics)")
    print("="*60)
    for metric, score in results.items():
        print(f"{metric:25s}: {score:.3f}")

    print("\n" + "="*60)
    print("INTERPRETATION:")
    print("="*60)
    print("Faithfulness: Higher = less hallucinations")
    print("Answer Relevancy: Higher = responde la query directamente")
    print("Context Precision: Higher = relevant docs ranked high")
    print("Context Recall: Higher = context contiene info necesaria") 

# Reciprocal Rank Fusion (RRF) formula
# score_RRF(d) = Σ 1 / (k + rank_i(d))
# donde:
#   d = documento
#   k = constante (típicamente 60)
#   rank_i(d) = posición del doc en retriever i

def reciprocal_rank_fusion(sparse_results, dense_results, k=60):
    """
    Combina rankings de BM25 y vector search usando RRF.
    
    Args:
        sparse_results: Lista de doc IDs rankeados por BM25
        dense_results: Lista de doc IDs rankeados por embeddings
        k: Constante RRF (default 60, paper original)
    
    Returns:
        Lista de doc IDs ordenados por score RRF descendente
    """
    scores = {}

    # Score de sparse retriever
    for rank, doc_id in enumerate(sparse_results, start=1):
        scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank)

    # Score de dense retriever
    for rank, doc_id in enumerate(dense_results, start=1):
        scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank)

    # Ordenar por score RRF descendente
    ranked_docs = sorted(scores.items(), key=lambda x: x[1], reverse=True)

    return [doc_id for doc_id, score in ranked_docs]


# ============================================================
# EJEMPLO USO
# ============================================================

sparse = ["doc5", "doc2", "doc8", "doc1"]  # BM25 ranking
dense = ["doc2", "doc5", "doc3", "doc8"]   # Vector search ranking

final_ranking = reciprocal_rank_fusion(sparse, dense)
# Output: ["doc2", "doc5", "doc8", "doc1", "doc3"]
# doc2 ranked #1 porque aparece alto en AMBOS retrievers

"""
Production-ready Hybrid Search RAG con LangChain + Pinecone.
Combina BM25 sparse retrieval + dense embeddings usando RRF.
Requirements: pip install langchain langchain-openai pinecone-client rank-bm25
"""

from typing import List, Dict, Any
import os
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_pinecone import PineconeVectorStore
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.schema import Document
from pinecone import Pinecone
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class HybridRAGSystem:
    """
    Sistema RAG production con hybrid search (BM25 + dense vectors).
    
    Features:
    - Reciprocal Rank Fusion (RRF) para combinar retrievers
    - Error handling robusto
    - Logging estructurado para debugging
    - Configuración flexible de weights
    """

    def __init__(
        self,
        pinecone_index_name: str,
        openai_api_key: str,
        pinecone_api_key: str,
        bm25_weight: float = 0.5,
        dense_weight: float = 0.5
    ):
        """
        Inicializa hybrid RAG system.
        
        Args:
            pinecone_index_name: Nombre del índice Pinecone existente
            openai_api_key: API key OpenAI para embeddings y LLM
            pinecone_api_key: API key Pinecone
            bm25_weight: Peso para sparse retriever (0-1)
            dense_weight: Peso para dense retriever (0-1)
        """
        self.pinecone_index_name = pinecone_index_name
        self.bm25_weight = bm25_weight
        self.dense_weight = dense_weight

        # Initialize embeddings
        self.embeddings = OpenAIEmbeddings(
            openai_api_key=openai_api_key,
            model="text-embedding-3-large"  # 3072 dims, mejor performance
        )

        # Initialize Pinecone
        pc = Pinecone(api_key=pinecone_api_key)
        self.vector_store = PineconeVectorStore(
            index_name=pinecone_index_name,
            embedding=self.embeddings,
            pinecone_api_key=pinecone_api_key
        )

        # Initialize LLM para generation
        self.llm = ChatOpenAI(
            openai_api_key=openai_api_key,
            model="gpt-4-turbo-preview",
            temperature=0.1  # Baja temperatura para respuestas precisas
        )

        logger.info(f"HybridRAGSystem initialized with index: {pinecone_index_name}")

    def create_hybrid_retriever(
        self,
        documents: List[Document],
        k: int = 5
    ) -> EnsembleRetriever:
        """
        Crea hybrid retriever combinando BM25 + dense vector search.
        
        Args:
            documents: Lista de documentos para BM25 indexing
            k: Número de documentos a retrievar
        
        Returns:
            EnsembleRetriever con RRF fusion
        """
        try:
            # BM25 sparse retriever (keyword-based)
            bm25_retriever = BM25Retriever.from_documents(
                documents,
                k=k
            )
            bm25_retriever.k = k

            # Dense vector retriever (semantic)
            dense_retriever = self.vector_store.as_retriever(
                search_kwargs={"k": k}
            )

            # Ensemble retriever con RRF fusion
            ensemble_retriever = EnsembleRetriever(
                retrievers=[bm25_retriever, dense_retriever],
                weights=[self.bm25_weight, self.dense_weight],
                # RRF se aplica automáticamente al combinar retrievers
            )

            logger.info(
                f"Hybrid retriever created: BM25 weight={self.bm25_weight}, "
                f"Dense weight={self.dense_weight}"
            )
            return ensemble_retriever

        except Exception as e:
            logger.error(f"Error creating hybrid retriever: {str(e)}")
            raise

    def query(
        self,
        question: str,
        documents: List[Document],
        k: int = 5
    ) -> Dict[str, Any]:
        """
        Ejecuta query RAG con hybrid search.
        
        Args:
            question: Pregunta del usuario
            documents: Documentos para search (BM25 + vector)
            k: Top-k documentos a retrievar
        
        Returns:
            Dict con answer, retrieved_docs y metadata
        """
        try:
            # Create hybrid retriever
            retriever = self.create_hybrid_retriever(documents, k=k)

            # Retrieve documentos relevantes
            retrieved_docs = retriever.get_relevant_documents(question)

            # Construir contexto para LLM
            context = "\n\n".join([doc.page_content for doc in retrieved_docs])

            # Prompt engineering para respuesta basada en contexto
            prompt = f"""Responde la pregunta basándote ÚNICAMENTE en el contexto proporcionado.
Si el contexto no contiene información suficiente, di explícitamente "No tengo información suficiente para responder eso".

Contexto:
{context}

Pregunta: {question}

Respuesta:"""

            # Generate response
            response = self.llm.predict(prompt)

            logger.info(f"Query processed successfully: '{question[:50]}...'")

            return {
                "answer": response,
                "retrieved_docs": retrieved_docs,
                "num_docs_retrieved": len(retrieved_docs),
                "retrieval_method": "hybrid_search_rrf"
            }

        except Exception as e:
            logger.error(f"Error processing query: {str(e)}")
            return {
                "answer": "Error procesando la pregunta. Por favor intenta de nuevo.",
                "error": str(e)
            }


# ============================================================
# EJEMPLO USO PRODUCTION
# ============================================================

if __name__ == "__main__":
    # Configuration
    PINECONE_INDEX = "production-docs"
    OPENAI_KEY = os.getenv("OPENAI_API_KEY")
    PINECONE_KEY = os.getenv("PINECONE_API_KEY")

    # Sample documents (en producción cargarías desde tu knowledge base)
    documents = [
        Document(
            page_content="NextJS es un framework React para production. Soporta SSR y SSG.",
            metadata={"source": "nextjs-intro.md"}
        ),
        Document(
            page_content="Vercel es la plataforma de deployment oficial de NextJS. Deploy con un click.",
            metadata={"source": "vercel-guide.md"}
        ),
        Document(
            page_content="Kubernetes StatefulSets manejan aplicaciones stateful como databases.",
            metadata={"source": "k8s-statefulsets.md"}
        ),
        # ... más documentos
    ]

    # Initialize hybrid RAG system
    rag_system = HybridRAGSystem(
        pinecone_index_name=PINECONE_INDEX,
        openai_api_key=OPENAI_KEY,
        pinecone_api_key=PINECONE_KEY,
        bm25_weight=0.5,  # Equal weight sparse/dense (tuneable)
        dense_weight=0.5
    )

    # Query con hybrid search
    result = rag_system.query(
        question="Cómo deployar NextJS en Vercel?",
        documents=documents,
        k=3  # Top-3 docs
    )

    print(f"Answer: {result['answer']}")
    print(f"Docs retrieved: {result['num_docs_retrieved']}")
    print(f"Sources: {[doc.metadata['source'] for doc in result['retrieved_docs']]}")

"""
Multimodal RAG con CLIP embeddings para text + images.
Permite queries textuales que retrievean documentos textuales E imágenes.
Requirements: pip install openai pillow pinecone-client sentence-transformers
"""

from typing import List, Dict, Any, Union
import os
import base64
from io import BytesIO
from PIL import Image
import requests
import openai
from pinecone import Pinecone
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class MultimodalRAGCLIP:
    """
    Sistema RAG multimodal usando CLIP embeddings.
    Soporta text documents + images en unified vector space.
    """

    def __init__(
        self,
        openai_api_key: str,
        pinecone_api_key: str,
        pinecone_index_name: str
    ):
        """
        Args:
            openai_api_key: API key OpenAI (para CLIP via GPT-4V)
            pinecone_api_key: API key Pinecone
            pinecone_index_name: Índice Pinecone (dimension=1024 para CLIP)
        """
        self.openai_client = openai.OpenAI(api_key=openai_api_key)

        # Initialize Pinecone
        pc = Pinecone(api_key=pinecone_api_key)
        self.index = pc.Index(pinecone_index_name)

        logger.info(f"MultimodalRAG initialized with index: {pinecone_index_name}")

    def embed_text_clip(self, text: str) -> List[float]:
        """
        Embedea texto usando CLIP-style embeddings via OpenAI.
        
        Args:
            text: String a embedear
        
        Returns:
            Vector embedding 1024 dimensions
        """
        try:
            response = self.openai_client.embeddings.create(
                model="text-embedding-3-large",  # 3072 dims, compatible CLIP-style
                input=text,
                dimensions=1024  # Reduce a 1024 para compatibilidad CLIP
            )
            return response.data[0].embedding

        except Exception as e:
            logger.error(f"Error embedding text: {str(e)}")
            raise

    def embed_image_clip(self, image_path: str) -> List[float]:
        """
        Embedea imagen usando CLIP embeddings via GPT-4V.
        
        NOTA: OpenAI no expone CLIP embeddings directamente en API.
        Esta función usa GPT-4V para generar description + embedea description.
        Para CLIP nativo, usar sentence-transformers CLIP model.
        
        Args:
            image_path: Path local o URL de imagen
        
        Returns:
            Vector embedding 1024 dimensions
        """
        try:
            # Load image
            if image_path.startswith('http'):
                response = requests.get(image_path)
                image = Image.open(BytesIO(response.content))
            else:
                image = Image.open(image_path)

            # APPROACH: Use GPT-4V to describe image, then embed description
            # (Production: usar sentence-transformers CLIP model para embeddings directos)

            # Convertir imagen a base64 para GPT-4V
            buffered = BytesIO()
            image.save(buffered, format="PNG")
            img_str = base64.b64encode(buffered.getvalue()).decode()

            # Generate detailed description con GPT-4V
            response = self.openai_client.chat.completions.create(
                model="gpt-4-vision-preview",
                messages=[
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
                                "text": "Describe this image in detail for search indexing. Include objects, colors, text, layout, context."
                            },
                            {
                                "type": "image_url",
                                "image_url": {
                                    "url": f"data:image/png;base64,{img_str}"
                                }
                            }
                        ]
                    }
                ],
                max_tokens=300
            )

            description = response.choices[0].message.content

            # Embed description (proxy for image embedding)
            embedding = self.embed_text_clip(description)

            logger.info(f"Image embedded via description: '{description[:100]}...'")
            return embedding

        except Exception as e:
            logger.error(f"Error embedding image: {str(e)}")
            raise

    def index_document(
        self,
        doc_id: str,
        content: Union[str, str],  # text content OR image path
        content_type: str,  # "text" or "image"
        metadata: Dict[str, Any] = None
    ):
        """
        Indexa documento (text o image) en Pinecone.
        
        Args:
            doc_id: Unique identifier
            content: String de texto O path a imagen
            content_type: "text" o "image"
            metadata: Metadata adicional (source, title, etc.)
        """
        try:
            # Generate embedding según content type
            if content_type == "text":
                embedding = self.embed_text_clip(content)
            elif content_type == "image":
                embedding = self.embed_image_clip(content)
            else:
                raise ValueError(f"Invalid content_type: {content_type}")

            # Prepare metadata
            full_metadata = {
                "content_type": content_type,
                "content": content[:500] if content_type == "text" else content,  # Store preview
                **(metadata or {})
            }

            # Upsert to Pinecone
            self.index.upsert(
                vectors=[
                    {
                        "id": doc_id,
                        "values": embedding,
                        "metadata": full_metadata
                    }
                ]
            )

            logger.info(f"Indexed {content_type} document: {doc_id}")

        except Exception as e:
            logger.error(f"Error indexing document: {str(e)}")
            raise

    def query_multimodal(
        self,
        query_text: str,
        top_k: int = 5,
        filter_content_type: str = None  # "text", "image", or None for both
    ) -> List[Dict[str, Any]]:
        """
        Query multimodal index con texto.
        Retrieva documentos textuales Y/O imágenes relevantes.
        
        Args:
            query_text: Texto de búsqueda
            top_k: Número de resultados
            filter_content_type: Filtrar por tipo ("text", "image", None)
        
        Returns:
            Lista de documentos rankeados con metadata
        """
        try:
            # Embed query
            query_embedding = self.embed_text_clip(query_text)

            # Build filter si especificado
            filter_dict = None
            if filter_content_type:
                filter_dict = {"content_type": {"$eq": filter_content_type}}

            # Query Pinecone
            results = self.index.query(
                vector=query_embedding,
                top_k=top_k,
                include_metadata=True,
                filter=filter_dict
            )

            # Format results
            formatted_results = []
            for match in results['matches']:
                formatted_results.append({
                    "id": match['id'],
                    "score": match['score'],
                    "content_type": match['metadata']['content_type'],
                    "content": match['metadata']['content'],
                    "metadata": match['metadata']
                })

            logger.info(
                f"Query '{query_text[:50]}...' returned {len(formatted_results)} results"
            )
            return formatted_results

        except Exception as e:
            logger.error(f"Error querying: {str(e)}")
            raise


# ============================================================
# EJEMPLO USO PRODUCTION
# ============================================================

if __name__ == "__main__":
    # Configuration
    OPENAI_KEY = os.getenv("OPENAI_API_KEY")
    PINECONE_KEY = os.getenv("PINECONE_API_KEY")
    INDEX_NAME = "multimodal-docs"

    # Initialize system
    rag = MultimodalRAGCLIP(
        openai_api_key=OPENAI_KEY,
        pinecone_api_key=PINECONE_KEY,
        pinecone_index_name=INDEX_NAME
    )

    # Index text documents
    rag.index_document(
        doc_id="doc-1",
        content="Kubernetes architecture consists of master nodes and worker nodes...",
        content_type="text",
        metadata={"source": "k8s-architecture.md", "title": "Kubernetes Overview"}
    )

    # Index images
    rag.index_document(
        doc_id="img-1",
        content="./diagrams/k8s-architecture-diagram.png",
        content_type="image",
        metadata={"source": "k8s-architecture.md", "title": "K8s Architecture Diagram"}
    )

    # Query: retrieves BOTH text docs AND relevant images
    results = rag.query_multimodal(
        query_text="Explain Kubernetes architecture",
        top_k=5
    )

    print("\nMultimodal Search Results:")
    for i, result in enumerate(results, 1):
        print(f"{i}. [{result['content_type']}] Score: {result['score']:.3f}")
        print(f"   Content: {result['content'][:100]}...")
        print()

"""
Agentic RAG con LangGraph usando Reflection Pattern.
Agent reflexiona sobre retrieval quality y refina query si necesario.
Requirements: pip install langgraph langchain langchain-openai pinecone-client
"""

from typing import TypedDict, List, Annotated
import operator
import json
import os
import logging
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from langchain.schema import Document

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


# ============================================================
# STATE DEFINITION
# ============================================================

class AgentState(TypedDict):
    """
    Estado compartido entre nodos del graph.
    Cada nodo puede leer/modificar este state.
    """
    original_query: str  # Query inicial del usuario
    current_query: str  # Query actual (puede refinarse)
    retrieved_docs: Annotated[List[Document], operator.add]  # Docs acumulados
    reflection_count: int  # Contador de iterations
    quality_score: float  # Self-evaluation score (0-1)
    final_answer: str  # Respuesta generada
    needs_refinement: bool  # Flag: continuar loop o terminar


# ============================================================
# AGENT NODES (Steps del workflow)
# ============================================================

class AgenticRAGGraph:
    """
    LangGraph implementation de Agentic RAG con reflection.
    """

    def __init__(
        self,
        openai_api_key: str,
        pinecone_api_key: str,
        pinecone_index_name: str,
        max_reflections: int = 3
    ):
        self.max_reflections = max_reflections

        # Initialize components
        self.llm = ChatOpenAI(
            api_key=openai_api_key,
            model="gpt-4-turbo-preview",
            temperature=0
        )

        self.embeddings = OpenAIEmbeddings(
            openai_api_key=openai_api_key,
            model="text-embedding-3-large"
        )

        self.vector_store = PineconeVectorStore(
            index_name=pinecone_index_name,
            embedding=self.embeddings,
            pinecone_api_key=pinecone_api_key
        )

        # Build graph
        self.graph = self._build_graph()

    def retrieve(self, state: AgentState) -> AgentState:
        """
        Node 1: Retrieve documentos usando current_query.
        """
        query = state["current_query"]
        logger.info(f"Retrieving docs for query: '{query}'")

        # Retrieve top-5 docs
        docs = self.vector_store.similarity_search(query, k=5)
        state["retrieved_docs"] = docs

        logger.info(f"Retrieved {len(docs)} documents")
        return state

    def reflect(self, state: AgentState) -> AgentState:
        """
        Node 2: REFLECTION - Evalúa quality de docs retrieved.
        Decide si son suficientes o necesita refinar query.
        """
        query = state["current_query"]
        docs = state["retrieved_docs"]

        # Construir contexto de docs
        context = "\n\n".join([
            f"Doc {i+1}: {doc.page_content[:200]}..."
            for i, doc in enumerate(docs)
        ])

        # Prompt para self-evaluation
        reflection_prompt = f"""Eres un AI agent evaluando la calidad de documentos retrieved para responder una query.

Query original: {state["original_query"]}
Query actual: {query}

Documentos retrieved:
{context}

Evalúa si estos documentos son SUFICIENTES para responder la query con alta confianza.

Responde en formato JSON:
{{
    "quality_score": ,
    "reasoning": "