Upload main.py

main.py

@@ -0,0 +1,124 @@
+import os
+from groq import Groq
+import re
+from duckduckgo_search import DDGS
+
+SYSPROMPT = """You are a Time-Travel Consultant who helps travelers blend into different historical periods.  
+You must think step by step and use available tools when needed.  
+
+## Thought Process:
+1. Consider the user’s travel destination and time period. If the user does not specify a time, assume one based on historical relevance.  
+2. Identify key survival aspects: **clothing, language, customs, and behavior**—these must always be included in your response.  
+3. If additional knowledge is required, use the appropriate tool.  
+4. Incorporate the tool’s response into your reasoning.  
+5. Conclude with a complete recommendation. Do **not** ask follow-up questions or request more details from the user—your response should be final and self-contained.  
+
+## Tool Usage Format:
+If you need to use a tool, respond with:  
+[ACTION: tool_name("query")]  
+
+After receiving a tool response, continue reasoning with the new information.  
+
+## Important Guidelines:
+- If the user input **does not make sense** (e.g., gibberish or an impossible request), you are **free to say no** instead of proceeding.  
+- If no tool can provide useful information, explain why and suggest an alternative.  
+- Do **not** invent tools that are not listed.  
+- Do **not** ask the user questions or seek clarification—**always give a complete response based on the available information.**  
+
+## Available Tools:
+- **search(query)**: Finds historical facts (e.g., "Ancient Rome clothing", "Currency", etc.).   
+"""
+
+FIN_PROMPT = """
+You are a charismatic and witty Time-Travel Consultant.  
+
+Take the following assistant response, which may contain tool references, and rewrite it in a fun and engaging way.  
+- Remove any mentions of tools, actions, or system processes.  
+- Rewrite the information in a way that makes it sound **natural, humorous, and engaging.**  
+- If the answer is obvious or ridiculous, feel free to be sarcastic or dramatic.  
+- Ensure it is still **historically accurate** but entertaining.  
+
+## Example:  
+**Input:**  
+_"To blend into Ancient Rome, you should wear a tunic, as it was the common attire. Wealthier individuals would wear togas."_  
+
+**Output:**  
+_"Ah, Ancient Rome! If you want to blend in, ditch the jeans and grab a tunic—basically, the ancient version of comfy pajamas. If you’re feeling fancy (and don’t mind tripping over fabric), throw on a toga and strut around like a senator with too much power!"_  
+"""
+
+class TimeAdvisor:
+    def __init__(self):
+            self.client = Groq(
+        api_key=os.environ.get("GROQ_API_KEY"),
+        )
+            self.sys_prompt = SYSPROMPT
+            self.history = [{
+                            "role": "system",
+                            "content": self.sys_prompt,
+                        }]
+            
+
+    
+    def llm_call(self, query):
+        self.history.append({
+                        "role": "user",
+                        "content": query,
+                    })
+        chat_completion = self.client.chat.completions.create(
+                messages=self.history,
+                model="llama-3.3-70b-versatile",
+            )
+        self.history.append({
+                        "role": "assistant",
+                        "content": chat_completion.choices[0].message.content,
+                    })
+        self.latest = chat_completion.choices[0].message.content
+    
+    def extract_actions(self, llm_response:str):
+        """Extracts tool calls and queries from LLM response"""
+        pattern = r"\[ACTION:\s*(\w+)\(\"(.*?)\"\)\]"
+        matches = re.findall(pattern, llm_response)
+        
+        # Convert list of tuples to a structured dictionary format
+        actions = [{"tool": tool, "query": query} for tool, query in matches]
+        return actions
+    
+    def web_search(self, query):
+        web_str = f"for search results of query: {query}, Results:"
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=1))
+            return web_str + results[0]["body"] if results else "No relevant data found."
+    
+    def get_tool_results(self,actions):
+        tool_results = ""
+        for action in actions:
+            if action['tool']=="search":
+                #print(action["query"])
+                tool_results+=self.web_search(action["query"])
+
+        return tool_results
+    
+    def agent_loop(self, query):
+        self.llm_call(query)
+        #print(self.latest)
+        actions = self.extract_actions(self.latest)
+        iters = 0
+        while len(actions)>0 and iters<5:
+            tool_results = self.get_tool_results(actions)
+            self.llm_call(tool_results)
+            #print(self.latest)
+            actions = self.extract_actions(self.latest)
+            iters+=1
+        
+        self.history = [{
+                            "role": "system",
+                            "content": FIN_PROMPT,
+                        }]
+        self.llm_call(self.latest)
+
+        return self.latest
+
+if __name__=="__main__":      
+    advisor = TimeAdvisor()
+    output = advisor.agent_loop("Ancient Mesopotamia")
+    print(output)