update

agent.py

@@ -4,6 +4,9 @@ from langchain.chat_models import init_chat_model
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, AnyMessage
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langgraph.graph import add_messages, START, END, StateGraph
+from langchain_core.tools import tool
+from langgraph.prebuilt import ToolNode
+
 
 from typing_extensions import TypedDict, Annotated
 
@@ -30,33 +33,102 @@ def get_graph(llm):
         ]
     )
 
-    def call_model(state: State):
-        print("\n-------------------- Agent has been called -----------------------------------\n")
+    from langchain_community.retrievers import WikipediaRetriever
+
+    # Wikipedia retriever
+    wiki_retriever = WikipediaRetriever(load_max_docs =20)
+
+    @tool
+    def retrieve(query: str):
+        """
+        This function retrieves Wikipedia entries based on the query.
+        """
+        print("\n-------------------- Tool has been called --------------------\n")
+        print("The query is: ", query)
+        docs = wiki_retriever.invoke(query)
+        serialized = "\n\n".join(
+            (f"\nContent:\n{doc.page_content}")
+            for doc in docs
+        )
+
+        return serialized
+
+    tools = [retrieve]
+    tool_node = ToolNode(tools)
+    llm_with_tools = llm.bind_tools(tools)
+
+    def make_plan(state: State):
+        print("\n-------------------- Starting to create a plan --------------------\n")
+        # get all messages from the state
         messages = state["messages"]
+        # append planning message
         messages.append(HumanMessage(content="Write a plan how to solve this qustion?"))
+        # create prompt
+        prompt = prompt_template.invoke(messages)
+        # invoke LLM
+        response = llm.invoke(prompt)
+        print("The plan is: ", response.content)
+        return {"messages": [response], "aggregate": ["Plan"]}
+
+
 
 
-        prompt_plan = prompt_template.invoke(messages)
-        plan = llm.invoke(prompt_plan).content
-        messages.append(AIMessage(content=plan))
-        messages.append(HumanMessage(content="Now give me the answer to the question."))
+    def call_model(state: State):
+        print("\n-------------------- Agent has been called -----------------------------------\n")
+        # get all messages from the state
+        messages = state["messages"]
+        # append instruction message
+        messages.append(HumanMessage(content="Please provide me the answer to the question in detail."))
+        # create prompt
         prompt_answer = prompt_template.invoke(messages)
+        # invoke LLM
+        response = llm_with_tools.invoke(prompt_answer)
+        print("\nThe Prompt is: ", prompt_answer, "\n")
+        print("Agent has made a decision:\n",response, response.content, response.tool_calls)
+        print("Type von der Antwort: ",type(response))
+        return {"messages": [response], "aggregate": ["Agent"]}
+
+    def get_answer(state: State):
+        # get all messages from the state
+        messages = state["messages"]
+        # add prompt message
+        messages.append(HumanMessage(content="Please provide me just the plain answer to the question"))
+        # create prompt
+        prompt_answer = prompt_template.invoke(messages)
+        # invoke LLM
         response = llm.invoke(prompt_answer)
+        return {"messages": [response], "aggregate": ["Answer"]}
 
+    def should_continue(state: State):
+        print("\n-------------------- Decision of forwarding has been made --------------------\n")
+        messages = state["messages"]
+        print(type(messages[-1]))
+        print("The last message is: ", messages[-1])
 
-        print("\nThe Prompt is: ", prompt_answer, "\n")
+        if len(state["aggregate"]) < 8:
+            last_message = messages[-1]
+            if last_message.tool_calls:
 
-        print("Agent has made a decision: ",response.content)
-        return {"messages": [response], "aggregate": ["Agent"]}
+                return "tools"
+            return "Answer"
+        else:
+            return "Answer"
 
     # Build graph
     builder = StateGraph(State)
+    builder.add_node("tools", tool_node)
+    builder.add_node("Plan", make_plan)
     builder.add_node("Agent", call_model)
+    builder.add_node("Answer", get_answer)
+
 
 
     # Logic
-    builder.add_edge(START, "Agent")
-    builder.add_edge("Agent", END)
+    builder.add_edge(START, "Plan")
+    builder.add_edge("Plan", "Agent")
+    builder.add_conditional_edges("Agent", should_continue, ["tools", "Answer"])
+    builder.add_edge("tools", "Agent")
+    builder.add_edge("Answer", END)
 
     return builder.compile()
 

requirements.txt

@@ -7,4 +7,5 @@ python-dotenv~=1.1.0
 typing_extensions~=4.13.2
 langgraph~=0.3.34
 langchain-core~=0.3.56
-langchain-groq~=0.3.2
+langchain-groq~=0.3.2
+langchain-community ~=0.3.22