added updated files

Dockerfile

@@ -1,17 +1,11 @@
-# Use an official Python runtime as a parent image
 FROM python:3.10
-
-# Set the working directory
-WORKDIR /app
-
-# Copy your app files into the container
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
 COPY . .
-
-# Install required packages
-RUN pip install --no-cache-dir chainlit
-
-# Expose the port Chainlit will run on
-EXPOSE 7860
-
-# Start the Chainlit app
 CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

aisearch_v1.py

@@ -0,0 +1,302 @@
+import requests
+# from groq import Groq
+from bs4 import BeautifulSoup
+import os
+import re
+from dotenv import load_dotenv
+# from ollama import chat
+from google import genai
+from google.genai import types
+import asyncio
+from openai import AsyncAzureOpenAI 
+import urllib3
+# import bs4
+import fitz
+from pydantic import BaseModel
+import json
+from langchain_community.document_loaders import WebBaseLoader
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) 
+
+# load_dotenv()
+# GROQ_APIKEY = os.environ.get('GROQ_APIKEY')
+GOOGS_APIKEY = "AIzaSyDwkt2Ha0Y2eWOH0XonhJvEg5gXUfedRf4"
+SEARCH_ENGINE_ID = "f722438bf451a41a1"
+# GEMINI_APIKEY = os.environ.get('GEMINI_APIKEY')
+
+az_client = AsyncAzureOpenAI(
+        api_key='55b49aec1d734ba2a7e912bdef22af7a',
+        api_version="2024-12-01-preview",  # Use the appropriate API version
+        azure_endpoint='https://docuswiftchat-aillm-zgpfobsurevrg.openai.azure.com/'
+    )
+
+az_client_in = AsyncAzureOpenAI(
+        api_key='CvRegNn4vwFkcAs8LPkjqeAb0qdHO88AvVxsSrnshauwP9jDm9DsJQQJ99BCAC77bzfXJ3w3AAAAACOGdbvR',
+        api_version="2024-12-01-preview",  # Use the appropriate API version
+        azure_endpoint='https://docus-ai-ind954042238035.openai.azure.com'
+    )
+
+class ReportResponse(BaseModel):
+    title : str
+    justification : str
+    summary : str
+
+# class ListReport(BaseModel)
+    
+
+# client = genai.Client(api_key=GEMINI_APIKEY)
+gemini_client = genai.Client(api_key='AIzaSyBOtSrEcYlGuTZ-XZT5zJo3T_oPAWn3T2Y')
+# gemini_client1 = genai.Client(api_key='AIzaSyBOtSrEcYlGuTZ-XZT5zJo3T_oPAWn3T2Y')
+
+class aiSearch:
+    def __init__(self):
+        # self.query = query
+        # self.client = Groq(
+        #     api_key=GROQ_APIKEY,
+        # )
+        self.research_prompt = """
+        <role>
+        You are AI agent, who is specialized in research and analysis of Indian Judgments.
+        </role>
+        <input format>
+        [
+        {
+                    "title" : title of the url,
+                    "link" : url link,
+                    "snippet" : sinnept from link
+                    "text" : text from url webpage
+                },
+        {
+                    "title" : title of the url,
+                    "link" : url link,
+                    "snippet" : sinnept from link
+                    "text" : text from url webpage
+                }
+        ]
+        </input format>
+        <instructions>
+        1. Analyze each link and it's text to find relevant judgement to the user query .
+        2. Once analyzed extract judgement names and text of the judgement
+        3. In the response provide judgement name, one-two line justifications on why judgement is relevant to the query and text of the judgement in the webpage
+        4. If there is no relevant judgement return empty output
+        5. Think step by step before the response and only use the context for response.
+        </instructions>
+        <output format>
+        [
+        {
+           "title" : Judgement title,
+           "justification" : Justification on why judgement is relevant,
+           "summary" : Summary of the Judgement 
+        },
+        {
+           "title" : Judgement title,
+           "justification" : Justification on why judgement is relevant,
+           "summary" : Summary of the Judgement 
+        }
+        ]
+        </output format>
+        """
+        self.sp_final_report = """
+        <role>
+        You are AI agent, who is specialized in making formatted report.
+        </role>
+        <instructions>
+        1. Input will be in json format.
+        2. Do not include the report if it says no relevant judgement found and justifications says document not relevant
+        2. Return the output on markdown format 
+        </instructions>
+        <output format>
+        ##1. Judgement name (H2 heading)
+        Justification - reaosn to shortlist the judgement
+        Summary - Summary of the judgement
+
+        ##2. Judgement name (H2 heading)
+        Justification - reaosn to shortlist the judgement
+        Summary - Summary of the judgement
+        </output format>"""
+
+    async def gpt4omini(self,query):
+        chat_completion = await az_client_in.chat.completions.create(
+            messages=[
+                {
+                    "role" : "system",
+                    "content" : self.research_prompt
+                },
+                {
+                    "role": "user",
+                    "content": query,
+                }
+            ],
+            stream=True,
+            model="gpt4o-mini",
+            # temperature=0,
+            # reasoning_effort='low',
+            # response_format=ReportResponse
+        )
+
+        return chat_completion.choices[0].message.content
+
+    async def o3_mini(self,query):
+        chat_completion = await az_client.beta.chat.completions.parse(
+            messages=[
+                {
+                    "role" : "system",
+                    "content" : self.research_prompt
+                },
+                {
+                    "role": "user",
+                    "content": query,
+                }
+            ],
+            model="o3-mini",
+            # temperature=0,
+            # reasoning_effort='low',
+            response_format=ReportResponse
+        )
+
+        return chat_completion.choices[0].message.content
+    
+    async def gemini(self,prompt):
+        # try:
+            response = await gemini_client.aio.models.generate_content_stream(
+                model='gemini-2.0-flash',
+                contents = self.sp_final_report,
+                config=types.GenerateContentConfig(
+                    system_instruction=prompt,
+                    max_output_tokens= 4096,
+                    temperature= 0.1
+                )
+            )
+    
+            return response
+        
+        # except Exception as e:
+            # print(e)
+            # return '' 
+
+    def google_custom_search(self,query):
+        """
+        Make a request to Google Custom Search API
+        
+        Args:
+            query (str): Search query
+            api_key (str): Your Google API key
+            cx (str): Your Programmable Search Engine ID
+        
+        Returns:
+            dict: JSON response from the API
+        """
+        base_url = "https://www.googleapis.com/customsearch/v1"
+        en_query = f"{query}, Indian Judgments"
+        params = {
+            'q': en_query,
+            'key': GOOGS_APIKEY,
+            'cx': SEARCH_ENGINE_ID,
+            'gl': 'in'
+        }
+        
+        try:
+            response = requests.get(base_url, params=params,verify=False)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"An error occurred: {e}")
+            return None
+
+    def extract_text_from_html(self,url):
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5'
+            }
+            response = requests.get(url, headers=headers, verify=False)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            for element in soup(['script', 'style']):
+                element.decompose()
+
+            text_chunks = []
+            content_tags = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'div']
+
+            for tag in soup.find_all(content_tags):
+                text = tag.get_text(strip=True)
+                if len(text) < 3:
+                    continue
+                if tag.name in ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'div']:
+                    text = f"\n{text}\n"
+                elif tag.name == 'li':
+                    text = f"• {text}\n"
+                text = re.sub(r'\s+', ' ', text).strip()
+                if text:
+                    text_chunks.append(text)
+
+            text = ' '.join(text_chunks)
+            text = re.sub(r'\s+', ' ', text)
+            text = re.sub(r'\n\s*\n', '\n\n', text)
+        except Exception as e:
+            print(e)
+            text = ''
+        return text.strip()
+    
+    async def langchain_extracter(self,url):
+        loader = WebBaseLoader(web_paths=[url],verify_ssl=False)
+        docs = []
+        async for doc in loader.alazy_load():
+            docs.append(doc)
+        return docs[0].page_content
+    
+    def pdfreader(self,url):
+        ext_txt = ''
+        try:
+            response = requests.get(url)
+            # Open the PDF with PyMuPDF
+            with fitz.open(stream=response.content, filetype="pdf") as doc:
+                ext_txt = ''
+                for page_num, page in enumerate(doc, start=1):
+                    text = page.get_text()
+                    ext_txt+=text
+                    # print(f"--- Page {page_num} ---\n{text}\n")
+        except:
+            print(url)
+        return ext_txt
+
+    async def run_search(self,query):
+        self.results = self.google_custom_search(query)
+
+        self.url_items = []
+        for item in self.results['items']:
+            if len(self.url_items) < 10:
+                temp = {
+                    "title" : item["title"],
+                    "link" : item["link"],
+                    "snippet" : item["snippet"]
+                }
+                self.url_items.append(temp)
+
+        for item in self.url_items:
+            if item['link'].endswith(".pdf"):
+                item['text'] = self.pdfreader(item['link'])
+            else:
+                item['text'] = await self.langchain_extracter(item['link'])
+        
+        batch_size = 3
+        batches = [self.url_items[i:i+batch_size] for i in range(0, len(self.url_items), batch_size)]
+
+        tasks = []
+        for batch in batches:
+            context_prompt = f"""
+            <context>
+            {batch}
+            </context>
+
+            <user query>
+            {query}
+            </user query>
+            """
+            tasks.append(self.o3_mini(context_prompt))
+
+        # response = await self.gemini(context_promt)
+        batch_responses = await asyncio.gather(*tasks)
+        reports = [resp for resp in batch_responses]
+
+        stream_responses = await self.gemini(str(reports))
+        return stream_responses

app.py

@@ -1,11 +1,51 @@
 import chainlit as cl
+# from ollama import chat
+from aisearch_v1 import aiSearch
 
+@cl.step(type="tool")
+async def tool(msg):
 
-@cl.on_message
+    print(f"Message from user: {msg}")
+    
+    inst = aiSearch()
+    stream = await inst.run_search(msg)
+    return stream
+
+
+@cl.on_message  # this function will be called every time a user inputs a message in the UI
 async def main(message: cl.Message):
-    # Your custom logic goes here...
+    """
+    This function is called every time a user inputs a message in the UI.
+    It sends back an intermediate response from the tool, followed by the final answer.
+
+    Args:
+        message: The user's message.
+
+    Returns:
+        None.
+    """
+
+    msg = cl.Message(content="")
+    # Call the tool
+    # streams,sources = await tool(message.content)
+
+    streams = await tool(message.content)
+ 
+    # await cl.Message(content=result).send()
+
+    # for stream in streams:
+    async for part in streams:
+        if token := part.text or "":
+            await msg.stream_token(token)
+    
+    # # After streaming is complete, add citations if available
+    # if sources and len(sources) > 0:
+    #     # Add a divider
+    #     await msg.stream_token("\n\n---\n\n**Sources:**\n\n")
+        
+    #     # Add each source as a numbered citation
+    #     for i, source in enumerate(sources, 1):
+    #         citation = f"{i}. [{source['title']}]({source['link']})\n"
+    #         await msg.stream_token(citation)
 
-    # Send a response back to the user
-    await cl.Message(
-        content=f"Received: {message.content}",
-    ).send()
+    await msg.update()

requirements.txt

@@ -1 +1,7 @@
-chainlit
+chainlit
+beautifulsoup4
+python-dotenv
+google-genai
+openai
+PyMuPDF
+langchain-community