Update app.py

app.py

@@ -8,6 +8,7 @@ from langchain_text_splitters import RecursiveCharacterTextSplitter
 from sentence_transformers import SentenceTransformer
 import bs4
 import torch
+from transformers import pipeline
 
 # Define the embedding class
 class SentenceTransformerEmbedding:
@@ -106,16 +107,18 @@ query = st.text_input("Ask a question based on the blog post", placeholder="Type
 if 'chat_history' not in st.session_state:
     st.session_state['chat_history'] = []
 
-# CustomLanguageModel class with proper context argument
+# CustomLanguageModel class with summarization
 class CustomLanguageModel:
+    def __init__(self):
+        self.summarizer = pipeline("summarization", model="facebook/bart-large-cnn")  # Replace with desired model
+
     def generate(self, prompt, context):
-        # Implement logic to generate a response based on prompt and context
-        return f"Generated response: '{prompt}'. Key points from the context: '{self.summarize_context(context)}'."
+        summary = self.summarize_context(context)
+        return f"Generated response: '{prompt}'. Summary: '{summary}'."
 
     def summarize_context(self, context):
-        # Summarize the context to extract key information
-        # You could use an NLP summarization model for a more sophisticated approach
-        return " ".join(context.split()[:100])  # Returning the first 100 words as a simple summary
+        summarized = self.summarizer(context, max_length=200, min_length=100, do_sample=False)
+        return summarized[0]['summary_text']  # Ensure it outputs full, meaningful sentences
 
 # Define a callable class for RAGPrompt
 class RAGPrompt:
@@ -136,46 +139,43 @@ if st.button("Submit Query"):
                 parse_only=bs4.SoupStrainer()  # Adjust based on the user's URL structure
             ),
         )
-        try:
-            docs = loader.load()
+        docs = loader.load()
 
-            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-            splits = text_splitter.split_documents(docs)
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=300)
+        splits = text_splitter.split_documents(docs)
 
-            # Initialize the embedding model
-            embedding_model = SentenceTransformerEmbedding('all-MiniLM-L6-v2')
+        # Initialize the embedding model
+        embedding_model = SentenceTransformerEmbedding('all-MiniLM-L6-v2')
 
-            # Initialize Chroma with the embedding class
-            vectorstore = Chroma.from_documents(documents=splits, embedding=embedding_model)
+        # Initialize Chroma with the embedding class
+        vectorstore = Chroma.from_documents(documents=splits, embedding=embedding_model)
 
-            # Retrieve and generate using the relevant snippets of the blog
-            retriever = vectorstore.as_retriever()
+        # Retrieve and generate using the relevant snippets of the blog
+        retriever = vectorstore.as_retriever()
 
-            # Retrieve relevant documents
-            retrieved_docs = retriever.get_relevant_documents(query)
+        # Retrieve relevant documents
+        retrieved_docs = retriever.get_relevant_documents(query)
 
-            # Format the retrieved documents
-            def format_docs(docs):
-                return "\n\n".join(doc.page_content for doc in docs)
+        # Format the retrieved documents
+        def format_docs(docs):
+            return "\n\n".join(doc.page_content for doc in docs)
 
-            context = format_docs(retrieved_docs)
+        context = format_docs(retrieved_docs)
 
-            # Initialize the language model
-            custom_llm = CustomLanguageModel()
+        # Initialize the language model
+        custom_llm = CustomLanguageModel()
 
-            # Initialize RAG chain using the prompt
-            prompt = RAGPrompt()
+        # Initialize RAG chain using the prompt
+        prompt = RAGPrompt()
 
-            # Apply the prompt directly to the data (no chaining using `|`)
-            prompt_data = prompt({"question": query, "context": context})
+        # Apply the prompt directly to the data (no chaining using `|`)
+        prompt_data = prompt({"question": query, "context": context})
 
-            # Generate the response using the language model, focusing on the answer from the retrieved context
-            result = custom_llm.generate(prompt_data["question"], prompt_data["context"])
+        # Generate the response using the language model, focusing on the answer from the retrieved context
+        result = custom_llm.generate(prompt_data["question"], prompt_data["context"])
 
-            # Store query and response in session for chat history
-            st.session_state['chat_history'].append((query, result))
-        except Exception as e:
-            st.error(f"Error loading the blog or processing the query: {e}")
+        # Store query and response in session for chat history
+        st.session_state['chat_history'].append((query, result))
 
 # Display chat history
 for q, r in st.session_state['chat_history']: