add gpt4, agent

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.9
+FROM python:3.11
 RUN useradd -m -u 1000 user
 #USER user
 ENV HOME=/home/user \
@@ -13,6 +13,8 @@ RUN pip install qdrant-client
 RUN pip install langchain
 RUN pip install langchain-community
 RUN pip install langchain-openai
+RUN pip install duckduckgo-search==5.3.0b4
+RUN pip install langgraph
 COPY . .
 
 RUN chown -R user:user $HOME/app/Qdrant_db

app_one.py

@@ -1,14 +1,10 @@
-
-
-
-
-#from langchain.chat_models import ChatOpenAI
-#from langchain_community.chat_models import ChatOpenAI
 from langchain_openai import ChatOpenAI
 from langchain.prompts import ChatPromptTemplate
 from langchain.schema import StrOutputParser
 from langchain.schema.runnable import Runnable
+from langchain.schema.runnable import RunnablePassthrough
 from langchain.schema.runnable.config import RunnableConfig
+from langchain_core.messages import HumanMessage
 
 from langchain_community.vectorstores import Qdrant
 from qdrant_client import QdrantClient, models
@@ -16,66 +12,176 @@ from langchain_openai.embeddings import OpenAIEmbeddings
 
 from langchain.retrievers import MultiQueryRetriever
 
+# FROM THE LOADER
+from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
+from langchain.tools.retriever import create_retriever_tool
+
+from langchain_core.utils.function_calling import convert_to_openai_function
+from langgraph.prebuilt import ToolExecutor
+
+from typing import TypedDict, Annotated
+from langgraph.graph.message import add_messages
+
+from langgraph.prebuilt import ToolInvocation
+import json
+from langchain_core.messages import FunctionMessage
+
+from langchain_core.messages import BaseMessage
+
+from langgraph.graph import StateGraph, END
+
 from operator import itemgetter
 
 import chainlit as cl
 
+import os
+import getpass
+from uuid import uuid4
+
+
+#os.environ["LANGCHAIN_TRACING_V2"] = "true"
+#os.environ["LANGCHAIN_PROJECT"] = f"AML-au - {uuid4().hex[0:8]}"
+#os.environ["LANGCHAIN_API_KEY"] = getpass.getpass("LangSmith_API_Key: ")
+
+# PROMPTS IN USE
+duckduckgo_description = "Useful for when you need to answer questions about aml."
+
+aml_act_retriever_description = "Searches and returns excerpts from the aml act."
+
+agent_prompt = " Only conduct DuckDuckGo searches when asked about Anti Money Laundering (aml). "
+# If the question is not about aml answer with: I don't know.
+     
 
-model = ChatOpenAI(model="gpt-3.5-turbo", streaming=True)
 
 
+# Model used for the MultiQueryRetriever set with "some" temperature
+model = ChatOpenAI(model="gpt-3.5-turbo", streaming=True)	#temperature=0.7
+
+# Create Qdrant vectorstore as a retreiver
 client = QdrantClient(path="Qdrant_db")
 embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
 
+# Load collection from disk
 collection_name = "AML_act"
 qdrant =  Qdrant(client, collection_name, embedding_model)
 
 qdrant_retriever = qdrant.as_retriever()
 advanced_retriever = MultiQueryRetriever.from_llm(retriever=qdrant_retriever, llm=model)
 
+retreiver_tool = create_retriever_tool(
+    advanced_retriever,
+    "search_aml_act_retriever",
+    aml_act_retriever_description,
+)
+
+tool_belt = [DuckDuckGoSearchRun(description=duckduckgo_description +
+    "Input should be a search query."), retreiver_tool] 
+
+tool_executor = ToolExecutor(tool_belt)
+
+model_aml = ChatOpenAI(model="gpt-4", temperature=0)
+
+functions = [convert_to_openai_function(t) for t in tool_belt]
+model_aml = model_aml.bind_functions(functions)
+
+print(functions)
+
+# BUILD THE GRAPH
+class AgentState(TypedDict):
+  messages: Annotated[list, add_messages]
+  
+def call_model(state):
+  messages = state["messages"]
+  response = model_aml.invoke(messages)
+  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]}
+
+workflow = StateGraph(AgentState)
+workflow.add_node("agent", call_model)
+workflow.add_node("action", call_tool)
+workflow.set_entry_point("agent")
+
+def should_continue(state):
+  last_message = state["messages"][-1]
+
+  if "function_call" not in last_message.additional_kwargs:
+    return "end"
+
+  return "continue"
+
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+    {
+        "continue" : "action",
+        "end" : END
+    }
+)
+
+workflow.add_edge("action", "agent")
+
+app = workflow.compile()
+
+# Aux print, useful for debuging
+def print_messages(messages):
+  next_is_tool = False
+  initial_query = True
+  for message in messages["messages"]:
+    if "function_call" in message.additional_kwargs:
+      print()
+      print(f'Tool Call - Name: {message.additional_kwargs["function_call"]["name"]} + Query: {message.additional_kwargs["function_call"]["arguments"]}')
+      next_is_tool = True
+      continue
+    if next_is_tool:
+      print(f"Tool Response: {message.content}")
+      next_is_tool = False
+      continue
+    if initial_query:
+      print(f"Initial Query: {message.content}")
+      print()
+      initial_query = False
+      continue
+    print()
+    print(f"Agent Response: {message.content}")
 
 
 @cl.on_chat_start
 async def on_chat_start():
 
-    RAG_PROMPT = """
-
-    CONTEXT:
-    {context}
-
-    QUERY:
-    {question}
-
-    Answer the query above using the context provided. If you don't know the answer responde with: I don't know
-    """
-
-    rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT)
+    runnable =  app #| output_parser    # | StrOutputParser()
     
-    runnable = (
-    {"context": itemgetter("question") | advanced_retriever, "question": itemgetter("question")} | rag_prompt | model | StrOutputParser()
-    )
-
-
     cl.user_session.set("runnable", runnable)
 
 
 @cl.on_message
 async def on_message(message: cl.Message):
 
-    runnable = cl.user_session.get("runnable")  # type: Runnable
-    msg = cl.Message(content="")
-
     print("Query content----------", message.content)
 
-    for chunk in await cl.make_async(runnable.stream)(
-        {"question": message.content},
-        config=RunnableConfig(callbacks=[cl.LangchainCallbackHandler()]),
-    ):
-        await msg.stream_token(chunk)
+    input_message = HumanMessage(content=(agent_prompt + message.content))
+
+    response = app.invoke({"messages": [input_message]})
         
-    print("Answer content----------", msg.content)
-    
-    await msg.send()
-    
-    print("Answer content----------", msg.content)
+    await cl.Message(
+        content=response["messages"][-1].content).send()
     
+    print_messages(response)
+
+    print("Answer content----------", response["messages"][-1].content)
+
+