Sync from GitHub Actions

Lawverse/evaluation/metrics.py

@@ -35,10 +35,14 @@ class RagasMetrics:
 
     @staticmethod
     def f_recall(pred_answer, true_answer):
-        tp = sum(1 for p, t in zip(pred_answer, true_answer) if t.lower() in p.lower())
-        fn = len(true_answer) - tp
-        recall = tp / (tp + fn + 1e-8)
-        return round(recall, 4)
+        pred_tokens = set(" ".join(pred_answer).lower().split())
+        true_tokens = set(" ".join(true_answer).lower().split())
+
+        tp = len(pred_tokens & true_tokens)
+        fn = len(true_tokens - pred_tokens)
+
+        return round(tp / (tp + fn + 1e-8), 4)
+
 
 def compute_all_metrics(dataset : Dataset, preds, trues, llm : BaseRagasLLM, run_config : RunConfig):
     ragas = RagasMetrics()

Lawverse/pipeline/llm_loader.py

@@ -1,34 +1,4 @@
-from typing import Optional, List, Any
-from langchain_core.language_models.llms import LLM
-from openai import OpenAI
 import os
 from langchain_openai import ChatOpenAI
 
-# env = environ.Env()
-# environ.Env.read_env(Path(__file__).resolve().parent.parent.parent / ".env")
-
-# class LightningLLM(LLM):
-#     def __init__(self, api_key: str, model: str, **kwargs):
-#         super().__init__(**kwargs)
-#         object.__setattr__(self, "client", OpenAI(base_url="https://lightning.ai/api/v1/", api_key=api_key))
-#         object.__setattr__(self, "model", model)
-
-#     def _call(self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional = None, **kwargs: Any) -> str:
-        
-#         resp = self.client.chat.completions.create(
-#             model=self.model,
-#             messages=[{"role": "user", "content": [{"type": "text", "text": prompt}]}],
-#             temperature=0.1,
-#             max_tokens=10240
-#         )
-#         return resp.choices[0].message.content
-
-#     @property
-#     def _identifying_params(self):
-#         return {"model": self.model}
-
-#     @property
-#     def _llm_type(self):
-#         return "lightning_gpt"
-
-llm = ChatOpenAI(base_url='https://lightning.ai/api/v1/', api_key=os.getenv("API_KEY"), model=os.getenv("MODEL"))
+llm = ChatOpenAI(base_url='https://lightning.ai/api/v1/', api_key=os.getenv("API_KEY"), model="google/gemini-2.5-flash",)

Lawverse/pipeline/rag_pipeline.py

@@ -11,8 +11,10 @@ from Lawverse.logger import logging
 from Lawverse.exception import ExceptionHandle
 from Lawverse.utils.config import FAISS_PATH
 
-from langchain_classic.chains.conversational_retrieval.base import ConversationalRetrievalChain
-from langchain_core.prompts import PromptTemplate
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, PromptTemplate
+from langchain_classic.chains.combine_documents import create_stuff_documents_chain
+from langchain_classic.chains.retrieval import create_retrieval_chain
+from langchain_classic.chains.history_aware_retriever import create_history_aware_retriever
 import sys
 import pickle
 
@@ -117,20 +119,41 @@ def rag_components():
 def create_chat_chian(components, chat_id=None):
     try:
         memory_manager = ChatMemory(chat_id=chat_id)
-        memory = memory_manager.memory
-        
-        chain = ConversationalRetrievalChain.from_llm(
-            llm=llm,
-            retriever=components["retriever"],
-            combine_docs_chain_kwargs={"prompt": components["qa_prompt"]},
-            memory=memory,
-            return_source_documents=True,
-            output_key="answer"
+        retriever = components["retriever"]
+
+        contextualize_q_system_prompt = (
+            "Given a chat history and the latest user question "
+            "which might reference context in the chat history, "
+            "formulate a standalone question which can be understood "
+            "without the chat history. Do NOT answer the question, "
+            "just reformulate it if needed and otherwise return it as is."
         )
         
-        logging.info("RAG chain initialized successfully.")
-        return chain, memory_manager
-    
+        contextualize_q_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", contextualize_q_system_prompt),
+                MessagesPlaceholder("chat_history"),
+                ("human", "{input}"),
+            ]
+        )
+        history_aware_retriever = create_history_aware_retriever(
+            llm, retriever, contextualize_q_prompt
+        )
+        template_str = components["qa_prompt"].template
+        if "{question}" in template_str:
+            template_str = template_str.replace("{question}", "{input}")
+
+        qa_prompt = ChatPromptTemplate.from_template(template_str)
+        question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)
+
+        rag_chain = create_retrieval_chain(
+            history_aware_retriever, question_answer_chain
+        )
+        final_chain = rag_chain | (lambda x: x["answer"])
+
+        logging.info("LCEL RAG chain initialized successfully.")
+        return final_chain, memory_manager
+
     except Exception as e:
-        logging.error(f"Chat chain creation failed")
+        logging.error(f"Chat chain creation failed: {e}")
         raise ExceptionHandle(e, sys)

api/app.py

@@ -1,5 +1,5 @@
 from Lawverse.pipeline.rag_pipeline import rag_components, create_chat_chian
-from flask import Flask, render_template, request, jsonify, session
+from flask import Flask, render_template, request, jsonify, session, stream_with_context, Response
 from Lawverse.utils.config import MEMORY_DIR
 from Lawverse.logger import logging
 from Lawverse.monitoring.dashboard import monitor_bp
@@ -70,13 +70,17 @@ def rag_response():
         if not query:
             return jsonify({"error": "Empty message"}), 400
         
-        result = qa({"question": query})
-        memory_manager.save_memory()
-        
-        answer_markdown = result.get("answer","")
-        rendered_html = markdown.markdown(answer_markdown)
+        def generate():
+            try:
+                for chunk in qa.stream({"input": query}):
+                    yield chunk
+                memory_manager.save_memory()
+
+            except Exception as e:
+                logging.error(f"Error during stream generation: {e}")
+                yield f"**Error:** An error occurred while processing your request."
         
-        return jsonify({"answer": rendered_html})
+        return Response(stream_with_context(generate()), mimetype='text/plain')
     
     except Exception as e:
         logging.error(f"Chat error: {e}")

templates/chat.html

@@ -346,30 +346,44 @@
 
           addMessage(text, true);
           messageInput.value = "";
-
           const typing = showTyping();
-
           try {
-            const response = await fetch("/response", {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ message: text }),
-            });
-
-            const data = await response.json();
-            typing.remove();
+              const response = await fetch("/response", {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({ message: text }),
+              });
+              const reader = response.body.getReader();
+              const decoder = new TextDecoder();
+
+              typing.remove();
+              const aiBubble = document.createElement("div");
+              aiBubble.className = "message-bubble ai-message";
+              aiBubble.innerHTML = `
+                  <div class="flex items-start">
+                      <div class="w-8 h-8 rounded-full bg-gradient-to-r from-blue-500 to-cyan-500 mr-3"></div>
+                      <div>
+                          <p class="font-semibold text-cyan-300 mb-1">Lawverse AI</p>
+                          <div class="message-content"></div>
+                      </div>
+                  </div>`;
+              chatMessages.appendChild(aiBubble);
+              const contentDiv = aiBubble.querySelector(".message-content");
+
+              while (true) {
+                  const { value, done } = await reader.read();
+                  if (done) break;
+
+                  const chunk = decoder.decode(value);
+                  contentDiv.innerHTML += chunk;
+                  chatMessages.scrollTop = chatMessages.scrollHeight;
+              }
 
-            if (data.answer) {
-              addMessage(data.answer, false);
               loadSidebarChats();
-            } else if (data.error) {
-              addMessage(`⚠️ Error: ${data.error}`, false);
-            } else {
-              addMessage("⚠️ Unexpected response from server.", false);
-            }
-          } catch (error) {
-            typing.remove();
-            addMessage("❌ Error: Unable to connect to the server.", false);
+
+          } catch (err) {
+              typing.remove();
+              addMessage("❌ Streaming failed: " + err.message, false);
           }
         }