feat(add_deep_rishsearch): Add the graph and call functions for deep rish search

requirements.txt

@@ -6,10 +6,11 @@ langgraph
 langchain_core
 langchain_community
 langchain_huggingface
+langgraph-prebuilt
 streamlit
 transformers[torch]
 langchain_openai
-google-generativeai
+langchain_google_genai
 tf-keras
 tensorflow
 torch

src/graph/graph_builder.py

@@ -1,17 +1,21 @@
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.graph import StateGraph,START, END
 from state.state import StateVector
-from graph.state_vector_nodes import question_model
+from graph.state_vector_nodes import question_model,research_model
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
 
 class BuildGraphOptions():
     def __init__(self,question_model):
         self.graph_builder=StateGraph(StateVector) #For invocation
         self.questionmodel=question_model
-    def build_graph(self):
+    def load_research_model(self,research_model):
+        self.research_model=research_model
+    def build_question_graph(self):
         #workflow = self.graph_builder
 
         self.graph_builder.add_node("check_inputs", self.questionmodel.check_inputs)
-        self.graph_builder.add_node("create_prompt_template", self.questionmodel.create_prompt_template)
+        self.graph_builder.add_node("create_question_prompt_template", self.questionmodel.create_question_prompt_template)
         self.graph_builder.add_node("generate_questions", self.questionmodel.generate_questions)
         # Set entry point
         self.graph_builder.set_entry_point("check_inputs")
@@ -21,10 +25,48 @@ class BuildGraphOptions():
             "check_inputs",
             self.questionmodel.should_continue,
             {
-                "create_prompt_template": "create_prompt_template",
+                "create_question_prompt_template": "create_question_prompt_template",
                 "terminate": END
             }
         )
-        self.graph_builder.add_edge("create_prompt_template", "generate_questions")
+        self.graph_builder.add_edge("create_question_prompt_template", "generate_questions")
         self.graph_builder.add_edge("generate_questions", END)
-        return self.graph_builder.compile()
+        return self.graph_builder.compile()
+    def build_research_graph(self,research_model:research_model):
+        self.graph_builder.add_node("check_inputs", self.questionmodel.check_inputs)
+        self.graph_builder.add_node("create_question_prompt_template", self.questionmodel.create_question_prompt_template)
+        self.graph_builder.add_node("generate_questions", self.questionmodel.generate_questions)
+        self.graph_builder.add_node("create_prompt_template", research_model.create_prompt_template)
+
+        # Set entry point
+        self.graph_builder.set_entry_point("check_inputs")
+        # Add conditional edges
+    
+        self.graph_builder.add_conditional_edges(
+            "check_inputs",
+            self.questionmodel.should_continue,
+            {
+                "create_question_prompt_template": "create_question_prompt_template",
+                "terminate": END
+            }
+        )
+        self.graph_builder.add_edge("create_question_prompt_template", "generate_questions")
+        self.graph_builder.add_node(research_model.tool_calling_llm,
+            name="tool_calling_llm",
+            description="Invoke the LLM with curated questions to answer.",)
+        #llm_with_tools,tools=research_model.tool_calling_agent()
+        self.graph_builder.add_node("tools", ToolNode(research_model.tools))
+        self.graph_builder.add_node(research_model.summary_answer,name="summary_answer",
+            description="Summarize the answer from the LLM using the information gathered from the tools.",)
+        self.graph_builder.add_edge("generate_questions","create_prompt_template")
+        self.graph_builder.add_edge("create_prompt_template","tool_calling_llm")
+
+        self.graph_builder.add_conditional_edges(
+                "tool_calling_llm",
+                # If the latest message (result) from assistant is a tool call -> tools_condition routes to tools
+                # If the latest message (result) from assistant is a not a tool call -> tools_condition routes to Summary answer with no retrieved docs
+                tools_condition,
+            )
+        self.graph_builder.add_edge("tools", "summary_answer")
+        self.graph_builder.add_edge("summary_answer", END)
+        return self.graph_builder.compile()

src/graph/state_vector_nodes.py

@@ -1,19 +1,29 @@
-from langchain_core.messages import SystemMessage,AIMessage,HumanMessage
-from langchain_core.output_parsers import NumberedListOutputParser
+
+from langchain_core.messages import SystemMessage,AIMessage,HumanMessage,ToolMessage
+from langchain_core.output_parsers import NumberedListOutputParser,JsonOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
 from state.state import StateVector
 from streamlitui.constants import *
 import torch
 import torch.nn.functional as F
 import tensorflow as tf
 import re
-class question_model():
+from langchain_openai import ChatOpenAI
+from langchain_community.tools.semanticscholar.tool import SemanticScholarQueryRun
+from langchain_community.utilities.semanticscholar import SemanticScholarAPIWrapper
+from langchain_community.tools.tavily_search import TavilySearchResults
+import pandas as pd
+
+
+class question_model:
     def __init__(self,loaded_tokenizer,loaded_model, llm, df_keys):
         #self.state=StateVector
         self.tokenizer=loaded_tokenizer
         self.distilbert_model=loaded_model
         self.genai_model=llm
         self.df_keys=df_keys
-    def create_prompt_template(self, state:StateVector) -> StateVector:
+    def create_question_prompt_template(self, state:StateVector) -> StateVector:
         """
         Creates a prompt template based on the state vector.
         """
@@ -24,7 +34,7 @@ class question_model():
         for topic, keywords in state['topic_kw'].items():
             state['messages'].append(SystemMessage(content=f"For the UN SDG Goal: {topic}\n. \
                                                 Use the following keywords : {', '.join(keywords)}. Generate questions related to the topic in the country of {state['country']} using these keywords."))
-        state['messages'].append(AIMessage(content="Based on the provided information, here is an enhanced version of the question: \n"))
+        state['messages'].append(AIMessage(content="Based on the provided information, here is an enhanced list of the question: \n"))
 
         return state
 
@@ -73,7 +83,7 @@ class question_model():
         """Determine whether to continue to prompt creation or terminate"""
         if not state.get('topic') or not state.get('topic_kw'):
             return "terminate"
-        return "create_prompt_template"
+        return "create_question_prompt_template"
     def generate_questions(self, state:StateVector) -> StateVector:
         """
         Generates questions based on the provided topics and keywords.
@@ -90,3 +100,153 @@ class question_model():
         #ai_response="\n".join(state['questions'])
         #state['messages'].append(AIMessage(content="Generated questions: "+ai_response))
         return state
+
+class research_model:
+    def __init__(self,llm):
+        self.llm=llm
+        self.local_analysis_file='src/graph/data_analyst_prompts.csv'
+        self.tool_names=["direct_semantic_scholar_query", "direct_tavily_search" ]
+        semantic_scholar_tool = SemanticScholarQueryRun(
+            api_wrapper=SemanticScholarAPIWrapper()
+        )
+        self.tools=[semantic_scholar_tool,self.direct_tavily_search]
+        # Bind the tool to the LLM
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
+        #self.tavily_api_key=tavily_api_key
+
+    def direct_semantic_scholar_query(self,query: str):
+
+        """Direct invocation of SemanticScholarQueryRun without agent"""
+        
+        # Create the tool directly
+        tool = SemanticScholarQueryRun(
+            api_wrapper=SemanticScholarAPIWrapper()
+        )
+        
+        # Invoke the tool directly
+        result = tool.invoke(query, k=10, output_parser=JsonOutputParser(), fields=["paperId","title","authors", "url","abstract","year","paperId"],sort="year")
+
+        return result
+
+    def direct_tavily_search(self,query: str):
+        """Direct invocation of TavilySearchResults without agent"""
+        # Create the tool directly
+        tavily = TavilySearchResults()
+        result = tavily.invoke(query, max_results=5, include_answer=True, include_snippet=True, include_source=True)
+        response=""
+        for r in result:
+            response +="Found a webpage: %s at %s" %(r['title'], r['url'])
+            response +="Summary of the page: %s" %r['content']
+            response +="Relevance score: %s" %r['score']
+        return response
+    def data_analysis(self,state:StateVector):
+        df_analyst=pd.read_csv(self.local_analysis_file)
+        analysis_prompt=[]
+        topics=state['topic']
+        for t in topics:
+            Goal_Number=t[0]
+            df_analyst=df_analyst[df_analyst['country']==state['country']]
+            df_analyst['goal_number']=df_analyst['goal_number'].astype(int)
+            df_analyst=df_analyst[df_analyst['goal_number']==Goal_Number]
+            #print(df_analyst.head())
+
+            if df_analyst.shape[0]>0:
+                analysis_prompt.extend(df_analyst['analysis_prompt'].to_list())
+        return "\n".join(analysis_prompt)
+    
+    def create_prompt_template(self,state:StateVector) -> ChatPromptTemplate:
+            """
+            Creates a prompt template based on the provided questions.
+            """
+            topic_string = ", ".join(f"{name}" for num, name in state['topic'])
+            keywords=[]
+            kw_string=''
+            for i,v in state['topic_kw'].items():
+                keywords.append(",".join(v))
+            kw_string += f" with keywords: {', '.join(keywords)}"
+            messages = [
+                    SystemMessage(content= f"You are an AI assistant that helps users find information about the Sustainable Development Goal: {topic_string}.\
+                                Your task is to answer questions related to this goal using the provided tools with toolNames: {self.tool_names}\
+                                    You will be provided with a list of questions to answer below: \
+                                    questions = {state["questions"]} "),
+
+                    #AIMessage(content="Using publications on Semantic Scholar and my own reference data, I will answer the questions related to the Sustainable Development Goal: %s." % topic),
+                    SystemMessage(content=f"Search for recent papers on {kw_string} in {state['country']}."),
+                    SystemMessage(content=f"Search for recent news on {kw_string} in {state['country']}."),
+                    SystemMessage(content=f"Search the internet for webpages on {kw_string} in {state['country']}."),
+                    #HumanMessage(content="Please provide a comprehensive answer to the questions based on the information gathered from the tools.")
+                ]
+            state['messages'] = messages
+            return state
+
+    def tool_calling_agent(self):
+        """Show how to bind the tool to LLM using tool calling"""
+        
+        # Initialize LLM
+        '''
+        llm = ChatOpenAI(
+            temperature=0.1,
+            model_name="gpt-4o-mini",
+            openai_api_key=openai_api_key
+        )
+        '''
+        # Create the tool
+        semantic_scholar_tool = SemanticScholarQueryRun(
+            api_wrapper=SemanticScholarAPIWrapper()
+        )
+        self.tools=[semantic_scholar_tool,self.direct_tavily_search]
+        # Bind the tool to the LLM
+        llm_with_tools = self.llm.bind_tools(tools)
+        
+        return llm_with_tools,tools
+
+
+    def tool_calling_llm(self,state:StateVector):
+        return {"messages":[self.llm_with_tools.invoke(state["messages"])]}
+
+    def summary_answer(self,state:StateVector)->StateVector:
+        """
+        Function to summarize the answer from the LLM.
+        This is a placeholder function that can be extended to include more complex summarization.
+        """
+        
+        initial_system_message= state["messages"][0] # This is the system message that sets the context for the LLM with the listed questions
+        initial_system_message.content += "Please provide a comprehensive answer to the questions. \n"
+        
+        tool_messages = [msg for msg in state["messages"] if isinstance(msg, ToolMessage)]
+        augmented_data=""
+        if tool_messages:
+            initial_system_message.content += "Use the following information gathered from the tools as reference information: \n"
+            
+            for tool_msg in tool_messages:
+                print(tool_msg.content, type(tool_msg.content))
+                Label_Source=""
+                if 'semanticscholar' in tool_msg.name.lower():
+                    Label_Source="(Source: Scholarly Publication Abstracts from Semantic Scholar)"
+                    augmented_data+= f"{tool_msg.content}\n"
+                elif 'tavily' in tool_msg.name.lower():
+                    Label_Source="(Source: News Search Results)"
+                    augmented_data += f"{tool_msg.content}\n"
+                else:
+                    print("Unknown Tool Call")
+
+                initial_system_message.content += f"{Label_Source} \n {augmented_data}\n"
+        analysis_prompt=self.data_analysis(state)
+        initial_system_message.content+=analysis_prompt
+        initial_system_message.content+="\n Assess if the resources indicate a general positive or negative trend and grade progress\
+            from 0-10 where 0 is very negative and 10 is very positive.\n"
+        initial_system_message.content+="\n Provide detailed answers to the questions and a list of references used."
+        state["messages"].append(initial_system_message)
+        '''
+        llm = ChatOpenAI(
+            temperature=0.4,
+            model_name="gpt-4o",
+            openai_api_key=openai_api_key
+        )
+        '''
+        #llm=ChatGoogleGenerativeAI(model='gemini-2.5-pro',google_api_key=google_api_key,temperature=0.3)
+        
+        #print(state["messages"][-1].content)
+        airesponse = self.llm.invoke(state["messages"][-1].content)
+        # For simplicity, we just return the messages as they are
+        return {"messages": [airesponse]}

src/llm/llm_setup.py

@@ -1,7 +1,8 @@
 import os 
 import streamlit as sl 
 from langchain_openai import ChatOpenAI
-import google.generativeai as genai
+
+from langchain_google_genai import ChatGoogleGenerativeAI
 class ModelSelection:
     def __init__(self,user_contols_input):
         self.user_controls_input=user_contols_input
@@ -16,16 +17,15 @@ class ModelSelection:
         if  selected_model=='OpenAI':      
             try: 
                 llm = ChatOpenAI(
-                temperature=0.3,
-                model_name="gpt-4",
+                temperature=0.1,
+                model_name="gpt-4o-mini",
                 openai_api_key=gen_api_key
             )
                 return llm
             except Exception as e:
                 raise ValueError(f"Error Ocuured With Exception : {e}")
         else: 
-            genai.configure(api_key=gen_api_key)
-            llm = genai.GenerativeModel('gemini-2.5-pro')
+            llm = ChatGoogleGenerativeAI(model='gemini-2.5-flash',google_api_key=gen_api_key,temperature=0.1)
             return llm
 
 

src/streamlit_app.py

@@ -5,11 +5,12 @@ from typing import List, Optional
 from transformers import DistilBertTokenizerFast, TFDistilBertForSequenceClassification
 from langchain_core.messages import AnyMessage, AIMessage,SystemMessage, HumanMessage,AIMessageChunk
 
+
 from streamlitui.constants import unsdg_countries
 from llm.llm_setup import ModelSelection
 import pandas as pd
 from state.state import StateVector
-from graph.state_vector_nodes import question_model
+from graph.state_vector_nodes import question_model,research_model
 from graph.graph_builder import BuildGraphOptions
 import re
 class StreamlitConfigUI:
@@ -104,27 +105,50 @@ if __name__=='__main__':
     
     if user_message and user_input['UN SDG Country']:
         state=StateVector(country=user_input['UN SDG Country'], seed_question=user_message, messages=[])
+        if user_input['selected_usecase']=='AskSmart SDG Assistant':
+            SmartQuestions=question_model(#StateVector=state,
+                                    loaded_tokenizer=loaded_tokenizer,
+                                    loaded_model=loaded_model, llm=llm, df_keys=df_keys)
+            builder=BuildGraphOptions(SmartQuestions)
+            graph=builder.build_question_graph()
+            with st.chat_message("assistant"):
+                intro="Hello, I am an assistant designed to help you learn about the 17 UN SDG goals listed here: https://sdgs.un.org/goals.\
+                            You can ask me about any of the goals or specific topics, and I will provide you with information and resources related to them.\
+                            I can also help you create a question related to the SDGs based on your input.\
+                            Please provide me with a topic or question related to the SDGs and select a country, and I will do my best to assist you." #, 
+                st.write(intro)
+            initial_input = {'country': user_input['UN SDG Country'], 'seed_question': user_message}
+            with st.chat_message("user"):st.write(user_message)
+            with st.chat_message("assistant"):
+                message_placeholder = st.empty()
+                accumulated_content = ""
+                for chunk in graph.stream(initial_input, stream_mode='messages'):
+                    message, meta=chunk
+                    if isinstance(message, AIMessage):
+                            accumulated_content += message.content
+                            message_placeholder.write(accumulated_content)
+        elif user_input['selected_usecase']=='DeepRishSearch': 
+            print("Deep Rishsearch")
+            SmartQuestions=question_model(#StateVector=state,
+                                    loaded_tokenizer=loaded_tokenizer,
+                                    loaded_model=loaded_model, llm=llm, df_keys=df_keys)
+            builder=BuildGraphOptions(SmartQuestions)
+            ResearchModel=research_model(llm=SmartQuestions.genai_model)
+            graph=builder.build_research_graph(ResearchModel)
+            with st.chat_message("assistant"):
+                intro="Hello, I am an assistant designed to help you learn about the 17 UN SDG goals listed here: https://sdgs.un.org/goals.\
+                            You can ask me about any of the goals or specific topics, and I will provide you with information and resources related to them.\
+                            I can also help you create a question related to the SDGs based on your input.\
+                            Please provide me with a topic or question related to the SDGs and select a country, and I will do my best to assist you." #, 
+                st.write(intro)
+            with st.chat_message("user"):st.write(user_message)
+            initial_input = StateVector({'country': user_input['UN SDG Country'], 'seed_question': user_message})
+            with st.chat_message("assistant"):
+                message_placeholder = st.empty()
+                accumulated_content = ""
+                for chunk in graph.stream(initial_input, stream_mode='messages'):
+                    message, meta=chunk
+                    if isinstance(message, AIMessage):
+                            accumulated_content += message.content
+                            message_placeholder.write(accumulated_content)
 
-        SmartQuestions=question_model(#StateVector=state,
-                                loaded_tokenizer=loaded_tokenizer,
-                                loaded_model=loaded_model, llm=llm, df_keys=df_keys)
-        builder=BuildGraphOptions(SmartQuestions)
-        graph=builder.build_graph()
-        with st.chat_message("assistant"):
-            intro="Hello, I am an assistant designed to help you learn about the 17 UN SDG goals listed here: https://sdgs.un.org/goals.\
-                        You can ask me about any of the goals or specific topics, and I will provide you with information and resources related to them.\
-                        I can also help you create a question related to the SDGs based on your input.\
-                        Please provide me with a topic or question related to the SDGs and select a country, and I will do my best to assist you." #, 
-            st.write(intro)
-        initial_input = {'country': user_input['UN SDG Country'], 'seed_question': user_message}
-        with st.chat_message("user"):st.write(user_message)
-        with st.chat_message("assistant"):
-            message_placeholder = st.empty()
-            accumulated_content = ""
-            for chunk in graph.stream(initial_input, stream_mode='messages'):
-                  message, meta=chunk
-                  if isinstance(message, AIMessage):
-                        accumulated_content += message.content
-                        message_placeholder.write(accumulated_content)
-    else: 
-         print("Deep Rishsearch")