agent ready to start

.gitignore

@@ -171,4 +171,7 @@ cython_debug/
 .ruff_cache/
 
 # PyPI configuration file
-.pypirc
+.pypirc
+
+# agent's log files
+log.txt

agent.py

@@ -1,18 +1,25 @@
 
+from flow import createFlow
+from logger import Logger
+import config
+
 from assignment_utils import getQuestionByPos
 
 
 class Agent:
-    def __init__(self):
-        pass
+    def __init__(self, logger):
+        self.logger = logger
 
     def invoke(self, question):
-        fixed_answer = "This is a default answer."
-        return fixed_answer
+        flow = createFlow(self.logger)
+        shared = { "question": question }
+        flow.run(shared)
+        return shared["answer"]
     
 
 if __name__ == "__main__":
-    agent = Agent()
+    logger = Logger(config.logLevel,config.logFile)
+    agent = Agent(logger)
     question = getQuestionByPos(0)
     print(question)
     response = agent.invoke(question['question'])

app.py

@@ -6,6 +6,7 @@ import pandas as pd
 
 import config
 from agent import Agent
+from logger import Logger
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
@@ -25,7 +26,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = Agent()
+        logger = Logger(config.logLevel,config.logFile)
+        agent = Agent(logger)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None

config.py

@@ -1,4 +1,11 @@
 
 baseApiUrl = "https://agents-course-unit4-scoring.hf.space"
 questionsUrl = f"{baseApiUrl}/questions"
-submitUrl = f"{baseApiUrl}/submit"
+submitUrl = f"{baseApiUrl}/submit"
+
+runLocal = True
+localModel = "llama3.2"
+hfMoldel = "(tbd)"
+
+logLevel = 'DEBUG'
+logFile = 'log.txt'

flow.py

@@ -0,0 +1,18 @@
+
+from pocketflow import Flow
+
+from nodes import Decide, Search, Answer
+
+def createFlow(logger):
+    decide = Decide()
+    decide.setLogger(logger)
+    search = Search()
+    search.setLogger(logger)
+    answer = Answer()
+    answer.setLogger(logger)
+
+    decide - "search" >> search
+    decide - "answer" >> answer
+    search - "decide" >> decide
+
+    return Flow(start=decide)

logger.py

@@ -0,0 +1,33 @@
+
+from datetime import datetime
+
+import config
+
+
+class Logger:
+    def __init__(self, logLevelName, logFile):
+        self.logLevels = {'DEBUG': 10, 'INFO': 20, 'ERROR': 30, 'CRITICAL': 40}
+        self.logLevel = self.logLevels[logLevelName]
+        self.logFile = logFile
+
+    def debug(self, message):
+        if self.logLevel >= self.logLevels['DEBUG']:
+            self.__log(f"{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} DEBUG {message}")
+
+    def info(self, message):
+        if self.logLevel >= self.logLevels['INFO']:
+            self.__log(f"{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} INFO  {message}")
+
+    def error(self, message):
+        if self.logLevel >= self.logLevels['ERROR']:
+            self.__log(f"{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} ERROR {message}")
+
+    def critical(self, message):
+        if self.logLevel >= self.logLevels['CRITICAL']:
+            self.__log(f"{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} ** CRITICAL ** {message}")
+
+    def __log(self, message):
+        print(message)
+        if config.logFile:
+            with open(config.logFile,"a") as fh:
+                fh.write(message + "\n")

nodes.py

@@ -0,0 +1,103 @@
+
+import yaml
+from pocketflow import Node
+
+from utils import callLLM, callWebSearch
+
+class Decide(Node):
+    def setLogger(self,logger):
+        self.logger = logger
+
+    def prep(self,shared):
+        context = shared.get("context","No previous search")
+        question = shared["question"]
+        return question,context
+    
+    def exec(self,inputs):
+        question,context = inputs
+        prompt = f"""
+### CONTEXT
+You are a research assistant that can search the web
+Question: {question}
+Previous research: {context}
+
+### ACTION SPACE
+[1] search
+  Description: Look up more information on the web
+  Parameters:
+  - query (str): what to search for
+
+[2] answer
+  Description: Answer the question with current knowledge
+  Parameters:
+  - answer (str): final answer to the question
+
+### NEXT ACTION
+Decide the next action based on the context and available actions.
+Return your response in the following format:
+```yaml
+thinking: |
+  <your step-by-step reasoning process>
+action: search OR answer
+reason: <why you choose this action>
+search_query: <specific search query if action is search>
+```
+IMPORTANT: Make sure to:
+1. Use proper indentation (4 spaces) for all multi-line fields
+2. Use the | character for multi-line text fields
+3. Keep single-line fields without the | character
+"""
+        response = callLLM(prompt)
+        self.logger.debug(f"=== CALLING LLM\n{prompt}\n=== LLM RESPONSE\n{response}\n\n==========\n\n")
+        yaml_str = response.replace("|","") #.split("```yaml")[1].split("```")[0].strip()
+        decision = yaml.safe_load(yaml_str)
+        return decision
+    
+    def post(self,shared,prep_res,exec_res):
+        if exec_res["action"] == "search":
+            shared["search_query"] = exec_res["search_query"]
+        return exec_res["action"]
+    
+
+class Search(Node):
+    def setLogger(self,logger):
+        self.logger = logger
+
+    def prep(self,shared):
+        return shared["search_query"]
+    
+    def exec(self,search_query):
+        results = callWebSearch(search_query)
+        self.logger.debug(f"*** SEARCHING\n{search_query}\n*** SEARCH RESULTS\n{results}\n\n**********\n\n")
+        return results
+    
+    def post(self,shared,prep_res,exec_res):
+        previous = shared.get("context","")
+        shared["context"] = f"{previous}\n\nSEARCH: {shared["search_query"]}\n\nRESULTS: {exec_res}"
+        return "decide"
+
+
+class Answer(Node):
+    def setLogger(self,logger):
+        self.logger = logger
+
+    def prep(self,shared):
+        return shared["question"],shared.get("context","")
+    
+    def exec(self,inputs):
+        question,context = inputs
+        prompt = f'''
+### CONTEXT
+Based on the following information, answer the question.
+Question: {question}
+Research: {context}
+
+### YOUR ANSWER
+Provide a comprehensive answer using research results
+'''
+        response = callLLM(prompt)
+        self.logger.debug(f"### CALLING LLM\n{prompt}\n### LLM RESPONSE\n{response}\n\n##########\n\n")
+        return response
+    
+    def post(self,shared,prep_res,exec_res):
+        shared["answer"] = exec_res

requirements.txt

@@ -5,4 +5,6 @@ langgraph
 langchain_openai
 langchain_huggingface
 langchain-community
-duckduckgo-search
+duckduckgo-search
+pocketflow
+#ollama

utils.py

@@ -1,13 +1,32 @@
 
+import config
+if config.runLocal:
+    from ollama import chat as OllamaChat
+
 from langchain_community.tools import DuckDuckGoSearchRun
 
 
+def callWebSearch(query):
+    return DuckDuckGo(query)
+
+def callLLM(query):
+    if config.runLocal:
+        return callLocalLLM(query)
+    else:
+        return callHfLLM(query)
+
 def DuckDuckGo(query):
     search_tool = DuckDuckGoSearchRun()
     results = search_tool.invoke(query)
     return results
 
+def callLocalLLM(query):
+    response = OllamaChat(model=config.localModel, messages=[ { 'role': 'user', 'content': query } ])
+    return response['message']['content']
+
+def callHfLLM(query):
+    return f"No way to call {config.hfMoldel} yet"
 
 if __name__ == "__main__":
-    response = DuckDuckGo("who is the presindent of France")
+    response = callWebSearch("who is the president of France")
     print(response)