Feedback and style changes

Simplified style of Candid resource links. Added feedback tab.

app.py

@@ -4,7 +4,6 @@ import os
 import gradio as gr
 
 from langchain_core.language_models.llms import LLM
-
 from langchain_openai.chat_models import ChatOpenAI
 from langchain_aws import ChatBedrock
 import boto3
@@ -15,9 +14,12 @@ from ask_candid.base.config.data import ALL_INDICES
 from ask_candid.utils import format_chat_ag_response
 from ask_candid.chat import run_chat
 
+try:
+    from feedback import FeedbackApi
+except ImportError:
+    from demos.feedback import FeedbackApi
+
 ROOT = os.path.dirname(os.path.abspath(__file__))
-BUCKET = "candid-data-science-reporting"
-PREFIX = "Assistant"
 
 class LoggedComponents(TypedDict):
     context: List[gr.components.Component]
@@ -27,6 +29,31 @@ class LoggedComponents(TypedDict):
     email: gr.components.Component
 
 
+def send_feedback(
+    chat_context,
+    found_helpful,
+    will_recommend,
+    comments,
+    email
+):
+    api = FeedbackApi()
+    total_submissions = 0
+
+    try:
+        response = api(
+            context=chat_context,
+            found_helpful=found_helpful,
+            will_recommend=will_recommend,
+            comments=comments,
+            email=email
+        )
+        total_submissions = response.get("response", 0)
+        gr.Info("Thank you for submitting feedback")
+    except Exception as ex:
+        raise gr.Error(f"Error submitting feedback: {ex}")
+    return total_submissions
+
+
 def select_foundation_model(model_name: str, max_new_tokens: int) -> LLM:
     if model_name == "gpt-4o":
         llm = ChatOpenAI(
@@ -92,7 +119,7 @@ def build_rag_chat() -> Tuple[LoggedComponents, gr.Blocks]:
             )
             llmname = gr.Radio(
                 label="Language model",
-                value="gpt-4o",
+                value="claude-3.5-haiku",
                 choices=list(Name2Endpoint.keys()),
                 interactive=True,
             )
@@ -118,8 +145,8 @@ def build_rag_chat() -> Tuple[LoggedComponents, gr.Blocks]:
                 type="messages",
                 show_label=False,
                 show_copy_button=True,
-                show_share_button=True,
-                show_copy_all_button=True,
+                show_share_button=None,
+                show_copy_all_button=False,
             )
             msg = gr.MultimodalTextbox(label="Your message", interactive=True)
             thread_id = gr.Text(visible=False, value="", label="thread_id")
@@ -132,12 +159,54 @@ def build_rag_chat() -> Tuple[LoggedComponents, gr.Blocks]:
             outputs=[msg, chatbot, thread_id],
         )
         chat_msg.then(format_chat_ag_response, chatbot, chatbot, api_name="bot_response")
-        logged = LoggedComponents(context=[thread_id, chatbot])
+        logged = LoggedComponents(context=chatbot)
     return logged, demo
 
 
+def build_feedback(components: LoggedComponents) -> gr.Blocks:
+    with gr.Blocks(theme=gr.themes.Soft(), title="Candid AI demo") as demo:
+        gr.Markdown("<h1>Help us improve this tool with your valuable feedback</h1>")
+
+        with gr.Row():
+            with gr.Column():
+                found_helpful = gr.Radio(
+                    [True, False], label="Did you find what you were looking for?"
+                )
+                will_recommend = gr.Radio(
+                    [True, False],
+                    label="Will you recommend this Chatbot to others?",
+                )
+                comment = gr.Textbox(label="Additional comments (optional)", lines=4)
+                email = gr.Textbox(label="Your email (optional)", lines=1)
+                submit = gr.Button("Submit Feedback")
+
+                components["found_helpful"] = found_helpful
+                components["will_recommend"] = will_recommend
+                components["comments"] = comment
+                components["email"] = email
+
+                # pylint: disable=no-member
+                submit.click(
+                    fn=send_feedback,
+                    inputs=[
+                        components["context"],
+                        components["found_helpful"],
+                        components["will_recommend"],
+                        components["comments"],
+                        components["email"]
+                    ],
+                    outputs=None,
+                    show_api=False,
+                    api_name=False,
+                    preprocess=False,
+                )
+
+    return demo
+
+
 def build_app():
-    _, candid_chat = build_rag_chat()
+    logger, candid_chat = build_rag_chat()
+    feedback = build_feedback(logger)
 
     with open(os.path.join(ROOT, "static", "chatStyle.css"), "r", encoding="utf8") as f:
         css_chat = f.read()
@@ -145,10 +214,13 @@ def build_app():
     demo = gr.TabbedInterface(
         interface_list=[
             candid_chat,
+            feedback
         ],
         tab_names=[
-            "AskCandid",
+            "Ask Candid",
+            "Feedback"
         ],
+        title="Ask Candid Assistant",
         theme=gr.themes.Soft(),
         css=css_chat,
     )

ask_candid/agents/schema.py

@@ -0,0 +1,27 @@
+from typing import List, Dict, TypedDict, Sequence, Union, Annotated
+
+from langchain_core.messages import BaseMessage
+from langgraph.graph.message import add_messages
+
+
+class Context(TypedDict):
+    """PCS + geonames context payload for common tasks like recommendations.
+    """
+    subject: List[str]
+    population: List[str]
+    geography: List[Union[str, int]]
+
+
+class AgentState(TypedDict):
+    """State of the chat agent for the execution graph(s).
+    """
+    # The add_messages function defines how an update should be processed
+    # Default is to replace. add_messages says "append"
+    messages: Annotated[Sequence[BaseMessage], add_messages]
+    user_input: str
+    org_dict: Dict
+
+    # Recommendation-specific fields
+    intent: str
+    context: Context
+    recommendation: str

ask_candid/base/config/constants.py

@@ -0,0 +1,4 @@
+START_SYSTEM_PROMPT = (
+    "You are a Candid subject matter expert on the social sector and philanthropy. "
+    "You should address the user's queries and stay on topic."
+)

ask_candid/chat.py

@@ -1,204 +1,12 @@
-from typing import List, Optional, Dict, Any, TypedDict, Annotated, Sequence
-from functools import partial
-import logging
-import os
+from typing import List, Dict, Tuple, Optional, Any
 
 import gradio as gr
-
-from langchain_core.messages import AIMessage, BaseMessage
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.language_models.llms import LLM
-
-from langgraph.prebuilt import tools_condition, ToolNode
 from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph.state import StateGraph
-from langgraph.graph.message import add_messages
-from langgraph.constants import START, END
-
-from ask_candid.tools.org_seach import extract_org_links_from_chatbot, embed_org_links_in_text, generate_org_link_dict
-from ask_candid.tools.question_reformulation import reformulate_question_using_history
-from ask_candid.utils import html_format_docs_chat, get_session_id
-from ask_candid.retrieval.elastic import retriever_tool
-
-ROOT = os.path.dirname(os.path.abspath(__file__))
-logging.basicConfig(format="[%(levelname)s] (%(asctime)s) :: %(message)s")
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-
-# TODO https://www.metadocs.co/2024/08/29/simple-domain-specific-corrective-rag-with-langchain-and-langgraph/
-
-
-class AgentState(TypedDict):
-    # The add_messages function defines how an update should be processed
-    # Default is to replace. add_messages says "append"
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-    user_input: str
-    org_dict: Dict
-
-
-def search_agent(state, llm: LLM, tools) -> AgentState:
-    """Invokes the agent model to generate a response based on the current state. Given
-    the question, it will decide to retrieve using the retriever tool, or simply end.
-
-    Parameters
-    ----------
-    state : _type_
-        The current state
-    llm : LLM
-    tools : _type_
-        _description_
-
-    Returns
-    -------
-    AgentState
-        The updated state with the agent response appended to messages
-    """
-
-    logger.info("---SEARCH AGENT---")
-    messages = state["messages"]
-    question = messages[-1].content
-
-    model = llm.bind_tools(tools)
-    response = model.invoke(messages)
-    # return a list, because this will get added to the existing list
-    return {"messages": [response], "user_input": question}
-
-
-def generate_with_context(state, llm: LLM) -> AgentState:
-    """Generate answer.
-
-    Parameters
-    ----------
-    state : _type_
-        The current state
-    llm : LLM
-    tools : _type_
-        _description_
-
-    Returns
-    -------
-    AgentState
-        The updated state with the agent response appended to messages
-    """
-
-    logger.info("---GENERATE ANSWER---")
-    messages = state["messages"]
-    question = state["user_input"]
-    last_message = messages[-1]
-
-    sources_str = last_message.content
-    sources_list = last_message.artifact  # cannot use directly as list of Documents
-    # converting to html string
-    sources_html = html_format_docs_chat(sources_list)
-    if sources_list:
-        logger.info("---ADD SOURCES---")
-    state["messages"].append(BaseMessage(content=sources_html, type="HTML"))
-
-    # Prompt
-    qa_system_prompt = """
-        You are an assistant for question-answering tasks in the social and philanthropic sector. \n
-        Use the following pieces of retrieved context to answer the question at the end. \n
-        If you don't know the answer, just say that you don't know. \n
-        Keep the response professional, friendly, and as concise as possible. \n
-        Question: {question}
-        Context: {context}
-        Answer:
-        """
-
-    qa_prompt = ChatPromptTemplate(
-        [
-            ("system", qa_system_prompt),
-            ("human", question),
-        ]
-    )
 
-    rag_chain = qa_prompt | llm | StrOutputParser()
-    response = rag_chain.invoke({"context": sources_str, "question": question})
-    # couldn't figure out why returning usual "response" was seen as HumanMessage
-    return {"messages": [AIMessage(content=response)], "user_input": question}
-
-
-def has_org_name(state: AgentState) -> AgentState:
-    """
-    Processes the latest message to extract organization links and determine the next step.
-
-    Args:
-        state (AgentState): The current state of the agent, including a list of messages.
-
-    Returns:
-        dict: A dictionary with the next agent action and, if available, a dictionary of organization links.
-    """
-    logger.info("---HAS ORG NAMES?---")
-    messages = state["messages"]
-    last_message = messages[-1].content
-    output_list = extract_org_links_from_chatbot(last_message)
-    link_dict = generate_org_link_dict(output_list) if output_list else {}
-    if link_dict:
-        logger.info("---FOUND ORG NAMES---")
-        return {"next": "insert_org_link", "org_dict": link_dict}
-    logger.info("---NO ORG NAMES FOUND---")
-    return {"next": END, "messages": messages}
-
-
-def insert_org_link(state: AgentState) -> AgentState:
-    """
-    Embeds organization links in the latest message content and returns it as an AI message.
-
-    Args:
-        state (dict): The current state, including the organization links and latest message.
-
-    Returns:
-        dict: A dictionary with the updated message content as an AIMessage.
-    """
-    logger.info("---INSERT ORG LINKS---")
-    messages = state["messages"]
-    last_message = messages[-1].content
-    messages.pop(-1)  # Deleting the original message because we will append the same one but with links
-    link_dict = state["org_dict"]
-    last_message = embed_org_links_in_text(last_message, link_dict)
-    return {"messages": [AIMessage(content=last_message)]}
-
-
-def build_compute_graph(llm: LLM, indices: List[str]) -> StateGraph:
-    candid_retriever_tool = retriever_tool(indices=indices)
-    retrieve = ToolNode([candid_retriever_tool])
-    tools = [candid_retriever_tool]
-
-    G = StateGraph(AgentState)
-    # Add nodes
-    G.add_node("reformulate", partial(reformulate_question_using_history, llm=llm))
-    G.add_node("search_agent", partial(search_agent, llm=llm, tools=tools))
-    G.add_node("retrieve", retrieve)
-    G.add_node("generate_with_context", partial(generate_with_context, llm=llm))
-    G.add_node("has_org_name", has_org_name)
-    G.add_node("insert_org_link", insert_org_link)
-
-    # Add edges
-    G.add_edge(START, "reformulate")
-    G.add_edge("reformulate", "search_agent")
-    # Conditional edges from search_agent
-    G.add_conditional_edges(
-        source="search_agent",
-        path=tools_condition,
-        path_map={
-            "tools": "retrieve",
-            END: "has_org_name",
-        },
-    )
-    G.add_edge("retrieve", "generate_with_context")
-
-    # Add edges
-    G.add_edge("generate_with_context", "has_org_name")
-    # Use add_conditional_edges for has_org_name
-    G.add_conditional_edges(
-        "has_org_name",
-        lambda x: x["next"],  # Now we're accessing the 'next' key from the dict
-        {"insert_org_link": "insert_org_link", END: END},
-    )
-    G.add_edge("insert_org_link", END)
-
-    return G
+from ask_candid.utils import get_session_id
+from ask_candid.graph import build_compute_graph
+from ask_candid.base.config.constants import START_SYSTEM_PROMPT
 
 
 def run_chat(
@@ -207,17 +15,10 @@ def run_chat(
     history: List[Dict],
     llm: LLM,
     indices: Optional[List[str]] = None,
-):
-    # https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_agentic_rag/#graph
-
+    enable_recommendations: bool = False
+) -> Tuple[gr.MultimodalTextbox, List[Dict[str, Any]], str]:
     if len(history) == 0:
-        history.append({
-            "role": "system",
-            "content": (
-                "You are a Candid subject matter expert on the social sector and philanthropy. "
-                "You should address the user's queries and stay on topic."
-            )
-        })
+        history.append({"role": "system", "content": START_SYSTEM_PROMPT})
 
     history.append({"role": "user", "content": user_input["text"]})
     inputs = {"messages": history}
@@ -225,14 +26,22 @@ def run_chat(
     thread_id = get_session_id(thread_id)
     config = {"configurable": {"thread_id": thread_id}}
 
-    workflow = build_compute_graph(llm=llm, indices=indices)
+    workflow = build_compute_graph(llm=llm, indices=indices, enable_recommendations=enable_recommendations)
 
     memory = MemorySaver()  # TODO: don't use for Prod
     graph = workflow.compile(checkpointer=memory)
     response = graph.invoke(inputs, config=config)
     messages = response["messages"]
-    last_message = messages[-1]
-    ai_answer = last_message.content
+
+    # Return the recommendation if there is any
+    recommendation = response.get("recommendation", None)
+    if recommendation:
+        ai_answer = recommendation
+    else:
+        # Fallback to the chatbot response
+        last_message = messages[-1]
+        ai_answer = last_message.content
+
     sources_html = ""
     for message in messages[-2:]:
         if message.type == "HTML":
@@ -240,12 +49,10 @@ def run_chat(
 
     history.append({"role": "assistant", "content": ai_answer})
     if sources_html:
-        history.append(
-            {
-                "role": "assistant",
-                "content": sources_html,
-                "metadata": {"title": "Sources HTML"},
-            }
-        )
+        history.append({
+            "role": "assistant",
+            "content": sources_html,
+            "metadata": {"title": "Sources HTML"},
+        })
 
     return gr.MultimodalTextbox(value=None, interactive=True), history, thread_id

ask_candid/graph.py

@@ -0,0 +1,177 @@
+from typing import List
+from functools import partial
+import logging
+
+from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.language_models.llms import LLM
+
+from langgraph.prebuilt import tools_condition, ToolNode
+from langgraph.graph.state import StateGraph
+from langgraph.constants import START, END
+
+from ask_candid.retrieval.elastic import retriever_tool
+from ask_candid.tools.recommendation import (
+    detect_intent_with_llm,
+    determine_context,
+    make_recommendation
+)
+from ask_candid.tools.question_reformulation import reformulate_question_using_history
+from ask_candid.tools.org_seach import has_org_name, insert_org_link
+from ask_candid.tools.search import search_agent
+from ask_candid.agents.schema import AgentState
+
+from ask_candid.utils import html_format_docs_chat
+
+logging.basicConfig(format="[%(levelname)s] (%(asctime)s) :: %(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def generate_with_context(state: AgentState, llm: LLM) -> AgentState:
+    """Generate answer.
+
+    Parameters
+    ----------
+    state : AgentState
+        The current state
+    llm : LLM
+
+    Returns
+    -------
+    AgentState
+        The updated state with the agent response appended to messages
+    """
+
+    logger.info("---GENERATE ANSWER---")
+    messages = state["messages"]
+    question = state["user_input"]
+    last_message = messages[-1]
+
+    sources_str = last_message.content
+    sources_list = last_message.artifact  # cannot use directly as list of Documents
+    # converting to html string
+    sources_html = html_format_docs_chat(sources_list)
+    if sources_list:
+        logger.info("---ADD SOURCES---")
+    state["messages"].append(BaseMessage(content=sources_html, type="HTML"))
+
+    # Prompt
+    qa_system_prompt = """
+        You are an assistant for question-answering tasks in the social and philanthropic sector. \n
+        Use the following pieces of retrieved context to answer the question at the end. \n
+        If you don't know the answer, just say that you don't know. \n
+        Keep the response professional, friendly, and as concise as possible. \n
+        Question: {question}
+        Context: {context}
+        Answer:
+        """
+
+    qa_prompt = ChatPromptTemplate([
+        ("system", qa_system_prompt),
+        ("human", question),
+    ])
+
+    rag_chain = qa_prompt | llm | StrOutputParser()
+    response = rag_chain.invoke({"context": sources_str, "question": question})
+    return {"messages": [AIMessage(content=response)], "user_input": question}
+
+
+def add_recommendations_pipeline_(
+    G: StateGraph,
+    reformulation_node_name: str = "reformulate",
+    search_node_name: str = "search_agent"
+) -> None:
+    """Adds execution sub-graph for recommendation engine flow. Graph changes are in-place.
+
+    Parameters
+    ----------
+    G : StateGraph
+        Execution graph
+    reformulation_node_name : str, optional
+        Name of the node which reforumates input queries, by default "reformulate"
+    search_node_name : str, optional
+        Name of the node which executes document search + retrieval, by default "search_agent"
+    """
+
+    # Nodes for recommendation functionalities
+    G.add_node("detect_intent_with_llm", detect_intent_with_llm)
+    G.add_node("determine_context", determine_context)
+    G.add_node("make_recommendation", make_recommendation)
+
+    # Check for recommendation query first
+    # Execute until reaching END if user asks for recommendation
+    G.add_edge(reformulation_node_name, "detect_intent_with_llm")
+    G.add_conditional_edges(
+        source="detect_intent_with_llm",
+        path=lambda state: "determine_context" if state["intent"] in ["rfp", "funder"] else search_node_name,
+        path_map={
+            "determine_context": "determine_context",
+            search_node_name: search_node_name
+        },
+    )
+    G.add_edge("determine_context", "make_recommendation")
+    G.add_edge("make_recommendation", END)
+
+
+def build_compute_graph(
+    llm: LLM,
+    indices: List[str],
+    enable_recommendations: bool = False
+) -> StateGraph:
+    """Execution graph builder, the output is the execution flow for an interaction with the assistant.
+
+    Parameters
+    ----------
+    llm : LLM
+    indices : List[str]
+        Semantic index names to search over
+    enable_recommendations : bool, optional
+        Set to `True` to allow the flow to generate recommendations based on context, by default False
+
+    Returns
+    -------
+    StateGraph
+        Execution graph
+    """
+
+    candid_retriever_tool = retriever_tool(indices=indices)
+    retrieve = ToolNode([candid_retriever_tool])
+    tools = [candid_retriever_tool]
+
+    G = StateGraph(AgentState)
+
+    G.add_node("reformulate", partial(reformulate_question_using_history, llm=llm))
+    G.add_node("search_agent", partial(search_agent, llm=llm, tools=tools))
+    G.add_node("retrieve", retrieve)
+    G.add_node("generate_with_context", partial(generate_with_context, llm=llm))
+    G.add_node("has_org_name", partial(has_org_name, llm=llm))
+    G.add_node("insert_org_link", insert_org_link)
+
+    if enable_recommendations:
+        add_recommendations_pipeline_(G, reformulation_node_name="reformulate", search_node_name="search_agent")
+    else:
+        G.add_edge("reformulate", "search_agent")
+
+    G.add_edge(START, "reformulate")
+    G.add_conditional_edges(
+        source="search_agent",
+        path=tools_condition,
+        path_map={
+            "tools": "retrieve",
+            END: "has_org_name",
+        },
+    )
+    G.add_edge("retrieve", "generate_with_context")
+    G.add_edge("generate_with_context", "has_org_name")
+    G.add_conditional_edges(
+        source="has_org_name",
+        path=lambda x: x["next"],  # Now we're accessing the 'next' key from the dict
+        path_map={
+            "insert_org_link": "insert_org_link",
+            END: END
+        },
+    )
+    G.add_edge("insert_org_link", END)
+    return G

ask_candid/retrieval/elastic.py

@@ -1,14 +1,17 @@
-from typing import List, Tuple, Dict, Iterable, Iterator, Optional, Any
+from typing import List, Tuple, Dict, Iterable, Iterator, Optional, Union, Any
 from dataclasses import dataclass
 from functools import partial
 from itertools import groupby
 
+from torch.nn import functional as F
+
 from pydantic import BaseModel, Field
 from langchain_core.documents import Document
 from langchain_core.tools import Tool
 
 from elasticsearch import Elasticsearch
 
+from ask_candid.services.small_lm import CandidSLM
 from ask_candid.base.config.connections import SEMANTIC_ELASTIC_QA
 from ask_candid.base.config.data import ElasticIndexMapping, ALL_INDICES
 
@@ -34,6 +37,21 @@ def build_text_expansion_query(
     fields: Tuple[str],
     model_id: str = ".elser_model_2_linux-x86_64"
 ) -> Dict[str, Any]:
+    """Builds a valid Elasticsearch text expansion query payload
+
+    Parameters
+    ----------
+    query : str
+        Search context string
+    fields : Tuple[str]
+        Semantic text field names
+    model_id : str, optional
+        ID of model deployed in Elasticsearch, by default ".elser_model_2_linux-x86_64"
+
+    Returns
+    -------
+    Dict[str, Any]
+    """
 
     output = []
 
@@ -60,7 +78,21 @@ def build_text_expansion_query(
     return {"query": {"bool": {"should": output}}}
 
 
-def query_builder(query: str, indices: List[str]):
+def query_builder(query: str, indices: List[str]) -> List[Dict[str, Any]]:
+    """Builds Elasticsearch multi-search query payload
+
+    Parameters
+    ----------
+    query : str
+        Search context string
+    indices : List[str]
+        Semantic index names to search over
+
+    Returns
+    -------
+    List[Dict[str, Any]]
+    """
+
     queries = []
     if indices is None:
         indices = list(ALL_INDICES)
@@ -111,7 +143,19 @@ def query_builder(query: str, indices: List[str]):
     return queries
 
 
-def multi_search(queries: List[ElasticHitsResult]):
+def multi_search(queries: List[Dict[str, Any]]) -> List[ElasticHitsResult]:
+    """Runs multi-search query
+
+    Parameters
+    ----------
+    queries : List[Dict[str, Any]]
+        Pre-built multi-search query payload
+
+    Returns
+    -------
+    List[ElasticHitsResult]
+    """
+
     results = []
     with Elasticsearch(
         cloud_id=SEMANTIC_ELASTIC_QA.cloud_id,
@@ -132,13 +176,77 @@ def multi_search(queries: List[ElasticHitsResult]):
     return results
 
 
-def get_query_results(search_text: str, indices: Optional[List[str]] = None):
+def get_query_results(search_text: str, indices: Optional[List[str]] = None) -> List[ElasticHitsResult]:
+    """Builds and executes Elasticsearch data queries from a search string.
+
+    Parameters
+    ----------
+    search_text : str
+        Search context string
+    indices : Optional[List[str]], optional
+        Semantic index names to search over, by default None
+
+    Returns
+    -------
+    List[ElasticHitsResult]
+    """
+
     queries = query_builder(query=search_text, indices=indices)
     return multi_search(queries)
 
 
-def reranker(query_results: Iterable[ElasticHitsResult]) -> Iterator[ElasticHitsResult]:
-    """Reranks Elasticsearch hits coming from multiple indicies/queries which may have scores on different scales.
+def retrieved_text(hits: Dict[str, Any]) -> str:
+    """Extracts retrieved sub-texts from documents which are strong hits from semantic queries for the purpose of
+    re-scoring by a secondary language model.
+
+    Parameters
+    ----------
+    hits : Dict[str, Any]
+
+    Returns
+    -------
+    str
+    """
+
+    text = []
+    for _, v in hits.items():
+        for h in (v.get("hits", {}).get("hits") or []):
+            for _, field in h.get("fields", {}).items():
+                for chunk in field:
+                    if chunk.get("chunk"):
+                        text.extend(chunk["chunk"])
+    return '\n'.join(text)
+
+
+def cosine_rescore(query: str, contexts: List[str]) -> List[float]:
+    """Computes cosine scores between retrieved contexts and the original query to re-score results based on overall
+    relevance to the original query.
+
+    Parameters
+    ----------
+    query : str
+        Search context string
+    contexts : List[str]
+        Semantic field sub-texts, order is by document retrieved from the original multi-search query.
+
+    Returns
+    -------
+    List[float]
+        Scores in the same order as the input document contexts
+    """
+
+    nlp = CandidSLM()
+    X = nlp.encode([query, *contexts]).vectors
+    X = F.normalize(X, dim=-1, p=2.)
+    cosine = X[1:] @ X[:1].T
+    return cosine.flatten().cpu().numpy().tolist()
+
+
+def reranker(
+    query_results: Iterable[ElasticHitsResult],
+    search_text: Optional[str] = None
+) -> Iterator[ElasticHitsResult]:
+    """Reranks Elasticsearch hits coming from multiple indices/queries which may have scores on different scales.
     This will shuffle results
 
     Parameters
@@ -151,6 +259,7 @@ def reranker(query_results: Iterable[ElasticHitsResult]) -> Iterator[ElasticHits
     """
 
     results: List[ElasticHitsResult] = []
+    texts: List[str] = []
     for _, data in groupby(query_results, key=lambda x: x.index):
         data = list(data)
         max_score = max(data, key=lambda x: x.score).score
@@ -160,19 +269,44 @@ def reranker(query_results: Iterable[ElasticHitsResult]) -> Iterator[ElasticHits
             d.score = (d.score - min_score) / (max_score - min_score + 1e-9)
             results.append(d)
 
+            if search_text:
+                text = retrieved_text(d.inner_hits)
+                texts.append(text)
+
+    # if search_text and len(texts) == len(results):
+    #     scores = cosine_rescore(search_text, texts)
+    #     for r, s in zip(results, scores):
+    #         r.score = s
+
     yield from sorted(results, key=lambda x: x.score, reverse=True)
 
 
-def get_results(user_input: str, indices: List[str]) -> List[ElasticHitsResult]:
+def get_results(user_input: str, indices: List[str]) -> Tuple[str, List[Document]]:
+    """End-to-end search and re-rank function.
+
+    Parameters
+    ----------
+    user_input : str
+        Search context string
+    indices : List[str]
+        Semantic index names to search over
+
+    Returns
+    -------
+    Tuple[str, List[Document]]
+        (concatenated text from search results, documents list)
+    """
+
     output = ["Search didn't return any Candid sources"]
-    page_content=[]
+    page_content = []
     content = "Search didn't return any Candid sources"
     results = get_query_results(search_text=user_input, indices=indices)
     if results:
-        output = get_reranked_results(results)
+        output = get_reranked_results(results, search_text=user_input)
         for doc in output:
             page_content.append(doc.page_content)
-        content = "/n/n".join(page_content)
+        content = "\n\n".join(page_content)
+
     # for the tool we need to return a tuple for content_and_artifact type
     return content, output
 
@@ -197,27 +331,38 @@ def get_context(field_name: str, hit: ElasticHitsResult, context_length: int = 1
     chunks_with_context = []
     long_text = hit.source.get(f"{field_name}", "")
     inner_hits_field = f"embeddings.{field_name}.chunks"
-    inner_hits = hit.inner_hits
-    found_chunks = inner_hits.get(inner_hits_field, {})
+    found_chunks = hit.inner_hits.get(inner_hits_field, {})
     if found_chunks:
         hits = found_chunks.get("hits", {}).get("hits", [])
         for h in hits:
             chunk = h.get("fields", {})[inner_hits_field][0]["chunk"][0]
-            chunk = chunk[3:-3] # cutting the middle because we may have tokenizing artefacts there
+
+            # cutting the middle because we may have tokenizing artifacts there
+            chunk = chunk[3: -3]
+
             # Find the start and end indices of the chunk in the large text
             start_index = long_text.find(chunk)
             if start_index != -1: # Chunk is found
                 end_index = start_index + len(chunk)
                 pre_start_index = max(0, start_index - context_length)
                 post_end_index = min(len(long_text), end_index + context_length)
-                context = long_text[pre_start_index:post_end_index]
-                chunks_with_context.append(context)
-    chunks_with_context_txt = '\n\n'.join(chunks_with_context)
+                chunks_with_context.append(long_text[pre_start_index:post_end_index])
+
+    return '\n\n'.join(chunks_with_context)
 
-    return chunks_with_context_txt
 
+def process_hit(hit: ElasticHitsResult) -> Union[Document, None]:
+    """Parse Elasticsearch hit results into data structures handled by the RAG pipeline.
+
+    Parameters
+    ----------
+    hit : ElasticHitsResult
+
+    Returns
+    -------
+    Union[Document, None]
+    """
 
-def process_hit(hit: ElasticHitsResult) -> Document | None:
     if "issuelab-elser" in hit.index:
         combined_item_description = hit.source.get("combined_item_description", "") # title inside
         description = hit.source.get("description", "")
@@ -300,17 +445,43 @@ def process_hit(hit: ElasticHitsResult) -> Document | None:
     return doc
 
 
-def get_reranked_results(results: List[ElasticHitsResult]) -> List[Document]:
+def get_reranked_results(results: List[ElasticHitsResult], search_text: Optional[str] = None) -> List[Document]:
+    """Run data re-ranking and document building for tool usage.
+
+    Parameters
+    ----------
+    results : List[ElasticHitsResult]
+    search_text : Optional[str], optional
+        Search context string, by default None
+
+    Returns
+    -------
+    List[Document]
+    """
+
     output = []
-    for r in reranker(results):
+    for r in reranker(results, search_text=search_text):
         hit = process_hit(r)
-        output.append(hit)
+        if hit is not None:
+            output.append(hit)
     return output
 
 
 def retriever_tool(indices: List[str]) -> Tool:
-    # cannot use create_retriever_tool because it only provides content losing all metadata on the way
-    # https://python.langchain.com/docs/how_to/custom_tools/#returning-artifacts-of-tool-execution
+    """Tool component for use in conditional edge building for RAG execution graph.
+    Cannot use `create_retriever_tool` because it only provides content losing all metadata on the way
+    https://python.langchain.com/docs/how_to/custom_tools/#returning-artifacts-of-tool-execution
+
+    Parameters
+    ----------
+    indices : List[str]
+        Semantic index names to search over
+
+    Returns
+    -------
+    Tool
+    """
+
     return Tool(
         name="retrieve_social_sector_information",
         func=partial(get_results, indices=indices),

ask_candid/services/small_lm.py

@@ -15,6 +15,7 @@ class Encoding:
 
 class CandidSLM(LambdaInvokeBase):
     """Wrapper around Candid's custom small language model.
+    For more details see https://dev.azure.com/guidestar/DataScience/_git/graph-ai?path=/releases/language.
     This services includes:
         * text encoding
         * document summarization
@@ -43,7 +44,7 @@ class CandidSLM(LambdaInvokeBase):
         )
 
     def encode(self, text: List[str]) -> Encoding:
-        response = self._submit_request({"text": text})
+        response = self._submit_request({"text": text, "path": self.Tasks.ENCODE.value})
 
         output = Encoding(
             inputs=(response.get("inputs") or []),

ask_candid/tools/org_seach.py

@@ -1,18 +1,26 @@
 from typing import List
+import logging
 import re
 
 from fuzzywuzzy import fuzz
 
 from langchain.output_parsers.openai_tools import JsonOutputToolsParser
-from langchain_openai.chat_models import ChatOpenAI
+# from langchain_openai.chat_models import ChatOpenAI
 from langchain_core.runnables import RunnableSequence
 from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.language_models.llms import LLM
+from langchain_core.messages import AIMessage
+from langgraph.constants import END
 from pydantic import BaseModel, Field
 
+from ask_candid.agents.schema import AgentState
 from ask_candid.services.org_search import OrgSearch
-from ask_candid.base.config.rest import OPENAI
+# from ask_candid.base.config.rest import OPENAI
 
 search = OrgSearch()
+logging.basicConfig(format="[%(levelname)s] (%(asctime)s) :: %(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 
 
 class OrganizationNames(BaseModel):
@@ -20,7 +28,7 @@ class OrganizationNames(BaseModel):
     orgnames: List[str] = Field(description="List of organization names")
 
 
-def extract_org_links_from_chatbot(chatbot_output: str):
+def extract_org_links_from_chatbot(chatbot_output: str, llm: LLM):
     """
     Extracts a list of organization names from the provided text.
 
@@ -51,9 +59,10 @@ def extract_org_links_from_chatbot(chatbot_output: str):
 
     try:
         parser = JsonOutputToolsParser()
-        llm = ChatOpenAI(model="gpt-4o", api_key=OPENAI["key"]).bind_tools([OrganizationNames])
+        # llm = ChatOpenAI(model="gpt-4o", api_key=OPENAI["key"]).bind_tools([OrganizationNames])
+        model = llm.bind_tools([OrganizationNames])
         prompt = ChatPromptTemplate.from_template(prompt)
-        chain = RunnableSequence(prompt, llm, parser)
+        chain = RunnableSequence(prompt, model, parser)
 
         # Run the chain with the input data
         result = chain.invoke({"chatbot_output": chatbot_output})
@@ -192,3 +201,44 @@ def embed_org_links_in_text(input_text: str, org_link_dict: dict):
         return input_text
 
     return input_text
+
+
+def has_org_name(state: AgentState, llm: LLM) -> AgentState:
+    """
+    Processes the latest message to extract organization links and determine the next step.
+
+    Args:
+        state (AgentState): The current state of the agent, including a list of messages.
+
+    Returns:
+        dict: A dictionary with the next agent action and, if available, a dictionary of organization links.
+    """
+    logger.info("---HAS ORG NAMES?---")
+    messages = state["messages"]
+    last_message = messages[-1].content
+    output_list = extract_org_links_from_chatbot(last_message, llm=llm)
+    link_dict = generate_org_link_dict(output_list) if output_list else {}
+    if link_dict:
+        logger.info("---FOUND ORG NAMES---")
+        return {"next": "insert_org_link", "org_dict": link_dict}
+    logger.info("---NO ORG NAMES FOUND---")
+    return {"next": END, "messages": messages}
+
+
+def insert_org_link(state: AgentState) -> AgentState:
+    """
+    Embeds organization links in the latest message content and returns it as an AI message.
+
+    Args:
+        state (dict): The current state, including the organization links and latest message.
+
+    Returns:
+        dict: A dictionary with the updated message content as an AIMessage.
+    """
+    logger.info("---INSERT ORG LINKS---")
+    messages = state["messages"]
+    last_message = messages[-1].content
+    messages.pop(-1)  # Deleting the original message because we will append the same one but with links
+    link_dict = state["org_dict"]
+    last_message = embed_org_links_in_text(last_message, link_dict)
+    return {"messages": [AIMessage(content=last_message)]}

ask_candid/tools/recommendation.py

@@ -0,0 +1,189 @@
+import logging
+import os
+
+from openai import OpenAI
+import requests
+
+from ask_candid.agents.schema import AgentState, Context
+from ask_candid.base.config.rest import OPENAI
+
+logging.basicConfig(format="[%(levelname)s] (%(asctime)s) :: %(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def detect_intent_with_llm(state: AgentState) -> AgentState:
+    """Detect query intent (which type of recommendation) and update the state."""
+    logger.info("---DETECT INTENT---")
+    client = OpenAI(api_key=OPENAI['key'])
+    # query = state["messages"][-1]["content"]
+    query = state["messages"][-1].content
+    prompt = f"""Classify the following query as one of the following categories: 
+    - 'none': The query is not asking for funding recommendations.
+    - 'funder': The query is asking for recommendations about funders, such as foundations or donors, who might provide longer-term or general funding.
+    - 'rfp': The query is asking for recommendations about specific, active Requests for Proposals (RFPs) that typically focus on short-term, recent opportunities with a deadline.
+
+    Your classification should consider:
+    1. RFPs often focus on active and time-bound opportunities for specific projects or programs.
+    2. Funders refer to broader, long-term funding sources like organizations or individuals who offer grants.
+
+    Query: "{query}"
+    """
+
+    response = client.chat.completions.create(
+        # model="gpt-4-turbo",
+        model="gpt-4o",
+        messages=[{"role": "system", "content": prompt}],
+        max_tokens=10,
+        stop=["\n"]
+    )
+
+    intent = response.choices[0].message.content.strip().lower()
+    state["intent"] = intent.strip("'").strip('"')  # Remove extra quotes
+    return state
+
+
+def determine_context(state: AgentState) -> AgentState:
+    """Extract subject/geography/population codes and update the state."""
+    logger.info("---GETTING RECOMMENDATION CONTEXT---")
+    query = state["messages"][-1].content
+
+    subject_codes, population_codes, geo_ids = [], [], []
+
+    # subject and population
+    autocoding_headers = {
+        'x-api-key': os.getenv("AUTOCODING_API_KEY"),
+        'Content-Type': 'application/json'
+    }
+    autocoding_params = {
+        'text': query,
+        'taxonomy': 'pcs-v3'
+    }
+    autocoding_response = requests.get(
+        os.getenv("AUTOCODING_API_URL"),
+        headers=autocoding_headers,
+        params=autocoding_params,
+        timeout=30
+    )
+    if autocoding_response.status_code == 200:
+        returned_pcs = autocoding_response.json()["data"] 
+        population_codes = [item['full_code'] for item in returned_pcs.get("population", [])]
+        subject_codes = [item['full_code'] for item in returned_pcs.get("subject", [])]
+
+    # geography
+    geo_headers = {
+        'x-api-key': os.getenv("GEO_API_KEY"),
+        'Content-Type': 'application/json'
+    }
+    geo_data = {
+        'text': query
+    }
+    geo_response = requests.post(os.getenv("GEO_API_URL"), headers=geo_headers, json=geo_data, timeout=30)
+    if geo_response.status_code == 200:
+        entities = geo_response.json()['data']['entities']
+        geo_ids = [entity['geo']['id'] for entity in entities if 'id' in entity['geo']]
+
+    state["context"] = Context(
+        subject=subject_codes,
+        population=population_codes,
+        geography=geo_ids
+    )
+    return state
+
+
+def make_recommendation(state: AgentState) -> AgentState:
+    """Make an API call based on the extracted context and update the state."""
+    # query = state["messages"][-1]["content"]
+    logger.info("---RECOMMENDING---")
+    org_id = "6908122"
+    funder_or_rfp = state["intent"]
+
+    # Extract context
+    contexts = state["context"]
+    subject_codes = contexts.get("subject", [])
+    population_codes = contexts.get("population", [])
+    geo_ids = contexts.get("geography", [])
+
+    # Prepare parameters
+    params = {
+        "subjects": ",".join(subject_codes),
+        "geos": ",".join([str(geo) for geo in geo_ids]),
+        "populations": ",".join(population_codes)
+    }
+    headers = {"x-api-key": os.getenv("FUNDER_REC_API_KEY")}
+    base_url = os.getenv("FUNDER_REC_API_URL")
+
+    # Initialize response
+    response = None
+
+    recommendation_display_text = ""
+
+    try:
+        # Make the API call based on intent
+        if funder_or_rfp == "funder":
+            response = requests.get(base_url, headers=headers, params=params, timeout=30)
+        elif funder_or_rfp == "rfp":
+            params["candid_entity_id"] = org_id #placeholder
+            response = requests.get(f"{base_url}/rfp", headers=headers, params=params, timeout=30)
+        else:
+            # Handle unknown intent
+            state["recommendation"] = "Unknown intent. Intent 'funder' or 'rfp' expected."
+            return state
+
+        # Validate response
+        if response and response.status_code == 200:
+            recommendations = response.json().get("recommendations", [])
+            if recommendations:
+                if funder_or_rfp == "funder":
+                    # Format recommendations
+                    recommendation_display_text = "Here are the top 10 recommendations. Click their profiles to learn more:\n" + "\n".join([
+                        f"{recommendation['funder_data']['main_sort_name']} - Profile: https://app.candid.org/profile/{recommendation['funder_id']}"
+                        for recommendation in recommendations
+                ])
+                elif funder_or_rfp == "rfp":
+                    recommendation_display_text = "Here are the top recommendations:\n" + "\n".join([
+                    f"Title: {rec['title']}\n"
+                    f"Funder: {rec['funder_name']}\n"
+                    f"Amount: {rec.get('amount', 'Not specified')}\n"
+                    f"Description: {rec.get('description', 'No description available')}\n"
+                    f"Deadline: {rec.get('deadline', 'No deadline provided')}\n"
+                    f"Application URL: {rec.get('application_url', 'No URL available')}\n"
+                    for rec in recommendations
+                    ])
+            else:
+                # No recommendations found
+                recommendation_display_text = "No recommendations were found for your query. Please try refining your search criteria."
+        elif response and response.status_code == 400:
+            # Handle bad request
+            error_details = response.json()
+            recommendation_display_text = (
+                "An error occurred while processing your request. "
+                f"Details: {error_details.get('message', 'Unknown error.')}"
+            )
+        elif response:
+            # Handle other unexpected status codes
+            recommendation_display_text = (
+                f"An unexpected error occurred (Status Code: {response.status_code}). "
+                "Please try again later or contact support if the problem persists."
+            )
+        else:
+            # Handle case where response is None
+            recommendation_display_text = "No response from the server. Please check your connection or try again later."
+
+    except requests.exceptions.RequestException as e:
+        # Handle network-related errors
+        recommendation_display_text = (
+            "A network error occurred while trying to connect to the recommendation service. "
+            f"Details: {str(e)}"
+        )
+    except Exception as e:
+        # Handle other unexpected errors
+        print(params)
+        recommendation_display_text = (
+            "An unexpected error occurred while processing your request. "
+            f"Details: {str(e)}"
+        )
+
+    # Update state with recommendations or error messages
+    state["recommendation"] = recommendation_display_text
+    return state

ask_candid/tools/search.py

@@ -0,0 +1,38 @@
+from typing import List
+import logging
+
+from langchain_core.language_models.llms import LLM
+from langchain_core.tools import Tool
+
+from ask_candid.agents.schema import AgentState
+
+logging.basicConfig(format="[%(levelname)s] (%(asctime)s) :: %(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def search_agent(state, llm: LLM, tools: List[Tool]) -> AgentState:
+    """Invokes the agent model to generate a response based on the current state. Given
+    the question, it will decide to retrieve using the retriever tool, or simply end.
+
+    Parameters
+    ----------
+    state : _type_
+        The current state
+    llm : LLM
+    tools : List[Tool]
+
+    Returns
+    -------
+    AgentState
+        The updated state with the agent response appended to messages
+    """
+
+    logger.info("---SEARCH AGENT---")
+    messages = state["messages"]
+    question = messages[-1].content
+
+    model = llm.bind_tools(tools)
+    response = model.invoke(messages)
+    # return a list, because this will get added to the existing list
+    return {"messages": [response], "user_input": question}

static/chatStyle.css

@@ -18,21 +18,22 @@
 }
 
 .source-item {
-    display: block;
+    /* display: block;
     min-width: 100px;
-    max-width: 45%;
+    max-width: 80%;
+    margin: 0 auto;
     height: fit-content;
     background-color: #febe10;
     color: black;
     padding: 5px;
     text-align: center;
     border-radius: 5px;
-    box-shadow: 0 2px 5px 0 rgba(0, 0, 0,0.2);
+    box-shadow: 0 2px 5px 0 rgba(0, 0, 0,0.2); */
     font-size: medium;
 }
 
 .ssearch-source {
-    text-decoration: none;
+    /* text-decoration: none; */
     box-sizing: border-box;
 }
 
@@ -42,7 +43,7 @@ button.upload-button.svelte-1d7elt4 {
 
 .candid-org-link {
     font-weight: bold;
-    text-decoration: none;
+    /* text-decoration: none; */
 }
 
 .candid-app-link {