Add app files

.gitignore

@@ -0,0 +1,6 @@
+.env
+__pycache__/
+.chainlit
+*.faiss
+*.pkl
+.files

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.9
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+COPY ./requirements.txt ~/app/requirements.txt
+WORKDIR $HOME/app
+RUN chown -R user:user $HOME/app/
+COPY --chown=user . $HOME/app/
+USER user
+RUN pip install -r requirements.txt
+RUN pip install langchain-openai
+COPY --chown=user . .
+CMD ["chainlit", "run", "app.py", "--port", "7860"]

README.md

@@ -1,10 +1,19 @@
----
-title: LibRAGentic Demo
-emoji: 👁
-colorFrom: indigo
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Welcome to the LibRAGentic Demo!
+
+This is a helpful AI bot that analyzes novel reviews written by the general public. Currently, only Reddit and Goodreads.com reviews are supported
+
+To use this app, prompt the AI with questions/statements structured similar to the following formats:
+
+* What does [Reddit/Goodreads] think about "X" book?
+* What is the overall sentiment of "X" from [Reddit/Goodreads]?
+* Summarize the [praises/criticisms] about "X" from [Reddit/Goodreads]
+* Highlight some [positive/negative] reviews about "X" from [Reddit/Goodreads]
+
+Note that:
+- You can simultaneously request reviews from both sites (replace the '/' with 'and')
+- You can request specific subreddit searches, e.g., "What does the books subreddit think about "X" book
+
+Future plans:
+* Implement additional website support
+* Analyze review comments
+* Book recommendations

app.py

@@ -0,0 +1,116 @@
+import os
+import json
+import chainlit as cl
+
+from operator import itemgetter
+from dotenv import load_dotenv
+
+from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
+from langchain_community.tools.reddit_search.tool import RedditSearchRun
+from langchain_community.utilities.reddit_search import RedditSearchAPIWrapper
+from langchain_openai import ChatOpenAI
+from langchain_core.utils.function_calling import convert_to_openai_function
+from langchain_core.messages import FunctionMessage, HumanMessage
+from langchain.schema.runnable.config import RunnableConfig
+from langchain.schema import StrOutputParser
+
+from langgraph.prebuilt import ToolExecutor
+from langgraph.prebuilt import ToolInvocation
+from langgraph.graph import StateGraph, END
+
+from searches import GoodReadsSearch
+from utils import AgentState
+
+async def call_model(state: AgentState, config: RunnableConfig):
+  messages = state["messages"]
+  response = await model.ainvoke(messages, config)
+  return {"messages" : [response]}
+
+def call_tool(state):
+  last_message = state["messages"][-1]
+
+  action = ToolInvocation(
+      tool=last_message.additional_kwargs["function_call"]["name"],
+      tool_input=json.loads(
+          last_message.additional_kwargs["function_call"]["arguments"]
+      )
+  )
+
+  response = tool_executor.invoke(action)
+
+  function_message = FunctionMessage(content=str(response), name=action.tool)
+
+  return {"messages" : [function_message]}
+
+def should_continue(state):
+  last_message = state["messages"][-1]
+
+  if "function_call" not in last_message.additional_kwargs:
+    return "end"
+
+  return "continue"
+
+load_dotenv()
+
+REDDIT_CLIENT_ID = os.environ["REDDIT_CLIENT_ID"]
+REDDIT_CLIENT_SECRET = os.environ["REDDIT_CLIENT_SECRET"]
+REDDIT_USER_AGENT = os.environ["REDDIT_USER_AGENT"]
+OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
+
+tool_belt = [
+    DuckDuckGoSearchRun(),
+    RedditSearchRun(
+        api_wrapper=RedditSearchAPIWrapper(
+            reddit_client_id=REDDIT_CLIENT_ID,
+            reddit_client_secret=REDDIT_CLIENT_SECRET,
+            reddit_user_agent=REDDIT_USER_AGENT,
+        )
+    ),
+    GoodReadsSearch()
+]
+
+tool_executor = ToolExecutor(tool_belt)
+model = ChatOpenAI(model="gpt-4o-mini", temperature=0, streaming=True)
+functions = [convert_to_openai_function(t) for t in tool_belt]
+model = model.bind_functions(functions)
+
+workflow = StateGraph(AgentState)
+workflow.add_node("agent", call_model)
+workflow.add_node("action", call_tool)
+workflow.set_entry_point("agent")
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+    {
+        "continue" : "action",
+        "end" : END
+    }
+)
+workflow.add_edge("action", "agent")
+
+app = workflow.compile()
+
+@cl.on_chat_start
+async def start_chat():
+    """
+    """
+    cl.user_session.set("agent", app)
+
+@cl.on_message  
+async def main(message: cl.Message):
+    """
+    """
+    agent = cl.user_session.get("agent")
+    inputs = {"messages" : [HumanMessage(content=str(message.content))]}
+    cb = cl.LangchainCallbackHandler(stream_final_answer=True)
+    config = RunnableConfig(callbacks=[cb])
+
+    msg = cl.Message(content="")   
+    await msg.send()    
+
+    async for event in agent.astream_events(inputs, config=config, version="v1"):
+        kind = event["event"]
+        if kind == "on_chat_model_stream":
+            await msg.stream_token(event["data"]["chunk"].content)
+
+    await msg.update()

requirements.txt

@@ -0,0 +1,9 @@
+chainlit==0.7.700
+langchain_core==0.2.21
+langchain==0.2.9
+langchain_community==0.2.7
+langgraph==0.1.8
+beautifulsoup4==4.12.3 
+duckduckgo_search==6.2.1
+praw==7.7.1
+python-dotenv==1.0.1

searches.py

@@ -0,0 +1,61 @@
+from typing import Optional, Type
+
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.tools import BaseTool
+
+from urllib import request
+from bs4 import BeautifulSoup
+
+class GoodReadsSearch(BaseTool):
+    name: str = "GoodReads"
+    description: str = """
+    Used to search for user reviews on Goodreads
+    using a rating system of 1 to 5 stars,
+    where 1 and 2 stars are considered as negative reviews,
+    3 stars is considered as neutral reviews,
+    and 4 and 5 starts are considered as positive reviews.
+    """
+
+    def fetchReviews(self, search_url: str) -> str:
+        response = request.urlopen(search_url).read().decode("utf-8")
+        soup = BeautifulSoup(response, 'html.parser')
+
+        content_url = ""
+        for attrs in soup.find_all('a'):
+            link = str(attrs.get("href"))    
+            if link.startswith("/book/show"):       
+                content_url = link
+                break
+        
+        book_url = "https://www.goodreads.com"+content_url
+        book_response = request.urlopen(book_url).read().decode("utf-8")
+        book_soup = BeautifulSoup(book_response, 'html.parser')
+
+        rating_count = 0
+        is_review = False
+        reviews = ""
+        for attrs in book_soup.find_all('span'):
+            if is_review:
+                review = str(attrs.get("class"))
+                if "Formatted" in review:
+                    reviews += attrs.get_text() + "\n\n"
+                    is_review = False
+            else:
+                rating = str(attrs.get("aria-label"))
+                if rating.startswith("Rating") and int(rating[7]) > 0 and rating[8]==" ":
+                    reviews += rating +"\n"
+                    rating_count+=1
+                    is_review = True
+        return reviews
+
+    def _run(
+            self, 
+            query: str,
+            run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Use the Goodreads tool."""
+        base_url = "https://www.goodreads.com/search?q="
+        book_title = query.replace(" ","+")
+        response = self.fetchReviews((base_url+book_title))
+        return response

utils.py

@@ -0,0 +1,5 @@
+from typing import TypedDict, Annotated
+from langgraph.graph.message import add_messages
+
+class AgentState(TypedDict):
+  messages: Annotated[list, add_messages]