flowchart TB
    subgraph encoder [Encoder]
        direction TB
        enc_input(Input Embedding) --> enc_pos(Positional Encoding)
        enc_pos --> enc_Nx1[Multi-Head Attention]
        enc_Nx1 --> enc_addnorm1[Add & Norm]
        enc_addnorm1 --> enc_ff1[Feed Forward]
        enc_ff1 --> enc_addnorm2[Add & Norm]
        enc_addnorm2 -.-> enc_Nx2[Multi-Head Attention]
        enc_Nx2 -.-> enc_addnorm3[Add & Norm]
        enc_addnorm3 -.-> enc_ff2[Feed Forward]
        enc_ff2 -.-> enc_addnorm4[Add & Norm]
        enc_addnorm4 -.-> enc_NxN[...]
        enc_NxN -.-> enc_output[Encoder Output]
    end

    subgraph decoder [Decoder]
        direction TB
        dec_input(Output Embedding) --> dec_pos(Positional Encoding)
        dec_pos --> dec_Nx1[Masked Multi-Head Attention]
        dec_Nx1 --> dec_addnorm1[Add & Norm]
        dec_addnorm1 --> dec_ff1[Feed Forward]
        dec_ff1 --> dec_addnorm2[Add & Norm]
        dec_addnorm2 -.-> dec_Nx2[Masked Multi-Head Attention]
        dec_Nx2 -.-> dec_addnorm3[Add & Norm]
        dec_addnorm3 -.-> dec_ff2[Feed Forward]
        dec_ff2 -.-> dec_addnorm4[Add & Norm]
        dec_addnorm4 -.-> dec_NxN[...]
        dec_NxN -.-> dec_output[Decoder Output]
    end

    enc_output --> dec_input
    dec_output --> lin[Linear]
    lin --> softmax[Softmax]
    softmax --> out(Output Probabilities)

    %% Styling
    classDef addnorm fill:#FFDD6B,stroke:#333,stroke-width:2px;
    class enc_addnorm1,enc_addnorm2,enc_addnorm3,enc_addnorm4,dec_addnorm1,dec_addnorm2,dec_addnorm3,dec_addnorm4 addnorm;
    classDef feedforward fill:#6BCB77,stroke:#333,stroke-width:2px;
    class enc_ff1,enc_ff2,dec_ff1,dec_ff2 feedforward;
    classDef attention fill:#4D96FF,stroke:#333,stroke-width:2px;
    class enc_Nx1,dec_Nx1,dec_Nx2 attention;
    classDef embedding fill:#FFAFCC,stroke:#333,stroke-width:2px;
    class enc_input,dec_input embedding;
    classDef softmaxlinear fill:#DB6E6E,stroke:#333,stroke-width:2px;
    class lin,softmax softmaxlinear;
    classDef output fill:#FFFFFF,stroke:#333,stroke-width:2px;
    class out output;

• Retrieval Augmented Generation (RAG) is an approach that combines traditional text generation techniques with retrieval-based methods to improve the quality and relevance of generated responses in conversational AI systems.
• In traditional generative models like GPT, responses are generated solely based on the input query or context. However, in RAG, the model also retrieves relevant documents or passages from a database and incorporates them into the generation process.

• Retrieval Models: These models are responsible for retrieving relevant documents or passages from a database based on the input query.
• Generation Models: These models generate responses by incorporating information from both the input query and the retrieved documents.
• Semantic Search: RAG relies on semantic search techniques to retrieve documents that are semantically similar to the input query, rather than relying solely on keyword matching.

• RAG improves the relevance and coherence of generated responses by incorporating external knowledge from retrieved documents.
• It allows the chatbot to provide more informative and contextually relevant responses, enhancing the overall user experience.

• RAG is widely used in conversational AI systems, chatbots, question answering systems, and information retrieval applications.
• It can be applied in various domains such as customer support, healthcare, education, and e-commerce to provide personalized and accurate responses to user queries.

• La génération augmentée par récupération (RAG) est une approche qui combine les techniques traditionnelles de génération de texte avec des méthodes basées sur la récupération pour améliorer la qualité et la pertinence des réponses générées dans les systèmes de conversation AI.
• Dans les modèles génératifs traditionnels comme GPT, les réponses sont générées uniquement sur la base de la requête d'entrée ou du contexte. Cependant, dans RAG, le modèle récupère également des documents ou des passages pertinents d'une base de données et les intègre dans le processus de génération.

• Modèles de récupération : Ces modèles sont responsables de la récupération de documents ou passages pertinents d'une base de données sur la base de la requête d'entrée.
• Modèles de génération : Ces modèles génèrent des réponses en incorporant des informations provenant à la fois de la requête d'entrée et des documents récupérés.
• Recherche sémantique : RAG s'appuie sur des techniques de recherche sémantique pour récupérer des documents qui sont sémantiquement similaires à la requête d'entrée, plutôt que de se baser uniquement sur une correspondance de mots-clés.

• RAG améliore la pertinence et la cohérence des réponses générées en incorporant des connaissances externes provenant de documents récupérés.
• Cela permet au chatbot de fournir des réponses plus informatives et contextuellement pertinentes, améliorant ainsi l'expérience utilisateur globale.

• RAG est largement utilisé dans les systèmes de conversation AI, les chatbots, les systèmes de réponse aux questions et les applications de récupération d'informations.
• Il peut être appliqué dans divers domaines tels que le support client, les soins de santé, l'éducation et le commerce électronique pour fournir des réponses personnalisées et précises aux requêtes des utilisateurs.

• LangChain is a framework that facilitates the integration of retrieval models with language models for retrieval augmented generation tasks.
• It provides a unified interface for building chatbots and conversational AI systems with enhanced response generation capabilities.

• Natural Language Processing (NLP) Pipeline: LangChain incorporates a comprehensive NLP pipeline for tasks such as tokenization, embedding generation, and semantic similarity calculation.

• Retrieval Models Integration: LangChain seamlessly integrates retrieval models, allowing the system to retrieve relevant documents or passages based on the input query.

  • Dense Retrieval Retriever-Reader (DRQA): This model retrieves relevant documents from a large corpus using dense vector representations and then uses a reader model to extract relevant information from these documents to generate responses.
  • Neural Generative Conversational Model with Retrieval Mechanism: This model first retrieves relevant context or responses from a large database of previous conversations using information retrieval techniques and then generates responses based on both the retrieved context and the current input.
  • Dual Encoder with Retrieval-Augmented Generation (DIALOGPT): This architecture uses a dual encoder to encode both the input query and the retrieved context, then generates a response based on this combined representation. It can be fine-tuned on conversational data to generate more contextually relevant responses.
  • Sequential Retrieval Model (SeqRM): This model sequentially retrieves relevant passages from a knowledge base and incorporates them into the generation process. At each step of generation, it retrieves the most relevant passage based on the current context and generates the next token accordingly.
  • BERT for Retriever-Reader (BRR): This model employs BERT-based retriever and reader components. The retriever selects relevant passages from a large corpus, and the reader extracts relevant information from these passages to generate responses.
• Language Models Integration: It also integrates language models for response generation, enabling the system to generate coherent and contextually relevant responses by incorporating information from both the input query and retrieved documents.

• Vector Database Interface: LangChain provides an interface for interacting with vector databases, allowing users to efficiently store and retrieve document embeddings for semantic search.

  • Milvus: Milvus is an open-source vector database designed for managing and serving vector embeddings at scale. It supports a variety of similarity search algorithms and provides efficient indexing and querying capabilities.
  • Faiss: Developed by Facebook AI Research (FAIR), Faiss is a widely-used library for efficient similarity search and clustering of dense vectors. It is optimized for high-dimensional vectors and offers GPU-accelerated indexing and querying.
  • Annoy: Annoy (Approximate Nearest Neighbors Oh Yeah) is a C++ library with Python bindings for approximate nearest neighbor search. It is designed for large-scale similarity search tasks and supports both CPU and GPU implementations.
  • Pinecone: Pinecone is a managed vector database service that provides real-time similarity search and recommendation capabilities. It offers a serverless architecture, automatic scaling, and integration with popular machine learning frameworks.
  • Elasticsearch with Vector Plugin: Elasticsearch is a distributed search and analytics engine that can be extended with plugins to support vector data. The Elasticsearch Vector Plugin allows indexing and querying of vector embeddings, enabling similarity search within Elasticsearch.
  • HNSW (Hierarchical Navigable Small World): While not a standalone database, HNSW is a data structure and algorithm commonly used for approximate nearest neighbor search. It can be integrated into existing databases or search engines to enable efficient similarity search.

• LangChain can be used to build chatbots, question answering systems, and information retrieval applications that leverage both generative and retrieval-based techniques for response generation.
• It provides flexibility and extensibility, allowing developers to customize and fine-tune the system according to specific use cases and requirements.

• LangChain est un cadre qui facilite l'intégration de modèles de récupération avec des modèles de langage pour des tâches de génération augmentée par récupération.
• Il fournit une interface unifiée pour la construction de chatbots et de systèmes de conversation AI avec des capacités améliorées de génération de réponses.

• Pipeline de Traitement du Langage Naturel (NLP) : LangChain intègre un pipeline NLP complet pour des tâches telles que la tokenisation, la génération d'embedding et le calcul de similarité sémantique.

• Intégration de Modèles de Récupération : LangChain intègre de manière transparente des modèles de récupération, permettant au système de récupérer des documents ou des passages pertinents en fonction de la requête d'entrée.

  • Retriever-Reader de Récupération Dense (DRQA) : Ce modèle récupère des documents pertinents d'un large corpus en utilisant des représentations vectorielles denses puis utilise un modèle lecteur pour extraire des informations pertinentes de ces documents afin de générer des réponses.
  • Modèle Conversationnel Génératif Neuronal avec Mécanisme de Récupération : Ce modèle récupère d'abord le contexte ou les réponses pertinents d'une grande base de données de conversations antérieures en utilisant des techniques de récupération d'informations puis génère des réponses basées à la fois sur le contexte récupéré et l'entrée actuelle.
  • Encodeur Dual avec Génération Augmentée par Récupération (DIALOGPT) : Cette architecture utilise un encodeur dual pour encoder à la fois la requête d'entrée et le contexte récupéré, puis génère une réponse basée sur cette représentation combinée. Il peut être ajusté sur des données conversationnelles pour générer des réponses plus contextuellement pertinentes.
  • Modèle de Récupération Séquentielle (SeqRM) : Ce modèle récupère séquentiellement des passages pertinents d'une base de connaissances et les intègre dans le processus de génération. À chaque étape de la génération, il récupère le passage le plus pertinent en fonction du contexte actuel et génère le jeton suivant en conséquence.
  • BERT pour Retriever-Reader (BRR) : Ce modèle emploie des composants retriever et reader basés sur BERT. Le retriever sélectionne des passages pertinents d'un large corpus, et le reader extrait des informations pertinentes de ces passages pour générer des réponses.
• Intégration de Modèles de Langage : Il intègre également des modèles de langage pour la génération de réponses, permettant au système de générer des réponses cohérentes et contextuellement pertinentes en incorporant des informations à la fois de la requête d'entrée et des documents récupérés.

• Interface de Base de Données Vectorielle : LangChain fournit une interface pour interagir avec les bases de données vectorielles, permettant aux utilisateurs de stocker et de récupérer efficacement des embeddings de documents pour la recherche sémantique.

  • Milvus : Milvus est une base de données vectorielle open-source conçue pour gérer et servir des embeddings vectoriels à grande échelle. Elle prend en charge une variété d'algorithmes de recherche de similarité et offre des capacités efficaces d'indexation et de requête.
  • Faiss : Développé par Facebook AI Research (FAIR), Faiss est une bibliothèque largement utilisée pour la recherche de similarité et le clustering de vecteurs denses efficaces. Elle est optimisée pour les vecteurs de haute dimension et offre des capacités d'indexation et de requête accélérées par GPU.
  • Annoy : Annoy (Approximate Nearest Neighbors Oh Yeah) est une bibliothèque C++ avec des liaisons Python pour la recherche approximative des plus proches voisins. Elle est conçue pour les tâches de recherche de similarité à grande échelle et prend en charge les implémentations CPU et GPU.
  • Pinecone : Pinecone est un service de base de données vectorielle géré qui fournit des capacités de recherche de similarité et de recommandation en temps réel. Il offre une architecture sans serveur, une mise à l'échelle automatique et une intégration avec des cadres d'apprentissage automatique populaires.
  • Elasticsearch avec Plugin Vectoriel : Elasticsearch est un moteur de recherche et d'analyse distribué qui peut être étendu avec des plugins pour supporter les données vectorielles. Le Plugin Vectoriel Elasticsearch permet l'indexation et la requête d'embeddings vectoriels, activant la recherche de similarité au sein d'Elasticsearch.
  • HNSW (Hierarchical Navigable Small World) : Bien qu'il ne soit pas une base de données autonome, HNSW est une structure de données et un algorithme couramment utilisé pour la recherche approximative des plus proches voisins. Il peut être intégré dans des bases de données ou des moteurs de recherche existants pour permettre une recherche de similarité efficace.

• LangChain peut être utilisé pour construire des chatbots, des systèmes de réponse aux questions et des applications de récupération d'informations qui tirent parti des techniques génératives et basées sur la récupération pour la génération de réponses.
• Il offre de la flexibilité et de l'extensibilité, permettant aux développeurs de personnaliser et d'ajuster le système selon des cas d'utilisation et des exigences spécifiques.

• Demo - We are going to explore LLM implementation
• Context prompt + LLM
• Multi-sources Context prompt + LLM

• Démo - Nous allons explorer la mise en œuvre de LLM
• Contexte d'invite + LLM
• Contexte d'invite multi-sources + LLM

# !pip install -q torch transformers accelerate bitsandbytes transformers sentence-transformers faiss-cpu pypdf streamlit langchain==0.1.6 langchain-community==0.0.19 langchain-core==0.1.23
# !pip install -q torch transformers
# !pip install -q transformers sentence-transformers
# !pip install -q faiss-cpu pypdf streamlit
# !pip install -q langchain==0.1.6 langchain-community==0.0.19 langchain-core==0.1.23

import locale  # In Google Colab, use UTF-8 locale to install LangChain
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from transformers import pipeline
from langchain_community.llms import HuggingFacePipeline
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
from langchain.schema.runnable import RunnablePassthrough
import streamlit as st

locale.getpreferredencoding = lambda: "UTF-8"

# Constants
PDF_FILE_PATH = "test_pdf.pdf"  # Update with your file path
CHUNK_SIZE = 500
CHUNK_OVERLAP = 100
OLLAMA_MODEL_NAME = "mistral"

loader = PyPDFLoader(PDF_FILE_PATH)
pages = loader.load_and_split()

print(f"Pages from the loader: {pages[0]} \n\n")

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP
)
doc_splits = text_splitter.split_documents(pages)

print(f"Pages from the loader: {doc_splits} \n\n")

db = FAISS.from_documents(
    doc_splits, HuggingFaceEmbeddings(model_name="BAAI/bge-base-en-v1.5")
)
retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": 4})

## Summarization
bart_model_name = "facebook/bart-large-cnn"
summarizer = pipeline("summarization", model=bart_model_name)

llm = HuggingFacePipeline(pipeline=summarizer)

prompt = ChatPromptTemplate.from_messages(
    [("system", "Summarize the story about Daisy:\n\n{context}")]
)

llm_chain = LLMChain(llm=llm, prompt=prompt)

"""**Combine the LLM + Retriever to create the RAG**"""
# retriever = db.as_retriever()
rag_chain = {"context": retriever, "question": RunnablePassthrough()} | llm_chain

# question = "Tell a story about a girl in the country side"

# print(llm_chain.invoke({"context": "", "question": question}))
# print('\n\n\n')
# print(rag_chain.invoke(question))

if __name__ == "__main__":
    st.title("Summarization with RAG Development")
    question = st.text_input("Summarize tex:", value=" ")
    if question != " ":
        st.title("Summarization - LLM Chain with no context")
        st.write(llm_chain.invoke({"context": "", "question": question})["text"])

    if question != " ":
        st.title("Summarization with RAG")
        st.write(rag_chain.invoke(question)["text"])