Initial commit with project setup and basic structure.

app.py

@@ -0,0 +1,200 @@
+import streamlit as st
+import requests
+import os
+from dotenv import load_dotenv
+from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser
+from langchain.schema import AgentAction, AgentFinish, HumanMessage
+from langchain.prompts import BaseChatPromptTemplate
+from langchain.tools import Tool
+from langchain.memory import ConversationBufferWindowMemory
+from transformers import pipeline
+from typing import List, Union
+import re
+
+# Load environment variables from .env
+load_dotenv()
+
+# Job API keys and endpoints
+JOB_API_KEY = os.getenv("JOB_API_KEY")  # Add your job API key here if required
+JOBS_API_URL = "https://jobs.github.com/positions.json"  # Example API endpoint (replace with an actual one)
+
+# Function to find global job openings
+def find_global_jobs():
+    try:
+        response = requests.get(JOBS_API_URL)
+        if response.status_code == 200:
+            jobs = response.json()
+            return [
+                {
+                    "title": job["title"],
+                    "company": job["company"],
+                    "location": job["location"],
+                    "url": job["url"]
+                } for job in jobs
+            ]
+        else:
+            return {"error": "Unable to fetch job data."}
+    except Exception as e:
+        return {"error": str(e)}
+
+# Function to find remote jobs
+def find_remote_jobs():
+    try:
+        response = requests.get(f"{JOBS_API_URL}?location=remote")
+        if response.status_code == 200:
+            jobs = response.json()
+            return [
+                {
+                    "title": job["title"],
+                    "company": job["company"],
+                    "url": job["url"]
+                } for job in jobs
+            ]
+        else:
+            return {"error": "Unable to fetch remote job data."}
+    except Exception as e:
+        return {"error": str(e)}
+
+# Function to find jobs near a location
+def find_jobs_near_location(location):
+    try:
+        response = requests.get(f"{JOBS_API_URL}?location={location}")
+        if response.status_code == 200:
+            jobs = response.json()
+            return [
+                {
+                    "title": job["title"],
+                    "company": job["company"],
+                    "location": job["location"],
+                    "url": job["url"]
+                } for job in jobs
+            ]
+        else:
+            return {"error": "Unable to fetch job data for location."}
+    except Exception as e:
+        return {"error": str(e)}
+
+# Define LangChain tools
+global_jobs_tool = Tool(
+    name="Global Job Finder",
+    func=find_global_jobs,
+    description="Find all job openings around the world."
+)
+
+remote_jobs_tool = Tool(
+    name="Remote Job Finder",
+    func=find_remote_jobs,
+    description="Find remote job openings."
+)
+
+local_jobs_tool = Tool(
+    name="Local Job Finder",
+    func=find_jobs_near_location,
+    description="Find job openings near a specified location. Input should be a city or region name."
+)
+
+# Set up the tools
+tools = [
+    global_jobs_tool,
+    remote_jobs_tool,
+    local_jobs_tool
+]
+
+# Set up a prompt template with history
+template_with_history = """You are JobSearchGPT, an AI assistant specialized in finding job openings. Answer the following questions as best you can. You have access to the following tools:
+
+{tools}
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question
+
+Begin! Remember to give detailed, informative answers
+
+Previous conversation history:
+{history}
+
+New question: {input}
+{agent_scratchpad}"""
+
+# Set up the prompt template
+class CustomPromptTemplate(BaseChatPromptTemplate):
+    template: str
+    tools: List[Tool]
+
+    def format_messages(self, **kwargs) -> str:
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\nObservation: {observation}\nThought: "
+
+        kwargs["agent_scratchpad"] = thoughts
+        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
+        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
+        formatted = self.template.format(**kwargs)
+        return [HumanMessage(content=formatted)]
+
+prompt_with_history = CustomPromptTemplate(
+    template=template_with_history,
+    tools=tools,
+    input_variables=["input", "intermediate_steps", "history"]
+)
+
+# Custom output parser
+class CustomOutputParser(AgentOutputParser):
+    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
+        if "Final Answer:" in llm_output:
+            return AgentFinish(
+                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
+                log=llm_output,
+            )
+        regex = r"Action: (.*?)[\n]*Action Input:[\s]*(.*)"
+        match = re.search(regex, llm_output, re.DOTALL)
+        if not match:
+            raise ValueError(f"Could not parse LLM output: `{llm_output}`")
+        action = match.group(1).strip()
+        action_input = match.group(2)
+        return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
+
+output_parser = CustomOutputParser()
+
+# Initialize HuggingFace pipeline
+pipe = pipeline("text-generation", model="gpt-neo-2.7B")  # Replace with a suitable model
+
+# LLM chain
+llm_chain = LLMChain(llm=pipe, prompt=prompt_with_history)
+tool_names = [tool.name for tool in tools]
+agent = LLMSingleActionAgent(
+    llm_chain=llm_chain, 
+    output_parser=output_parser,
+    stop=["\nObservation:"], 
+    allowed_tools=tool_names
+)
+
+memory = ConversationBufferWindowMemory(k=2)
+agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=memory)
+
+# Streamlit app
+st.title("Job Search Helper Agent")
+
+query = st.text_input("Enter your query:")
+
+if st.button("Submit"):
+    if query:
+        st.write("Debug: User Query ->", query)
+        with st.spinner("Processing..."):
+            try:
+                # Run the agent and get the response
+                response = agent_executor.run(query)  # Correct method is `run()`
+                st.success("Response:")
+                st.write(response)
+            except Exception as e:
+                st.error(f"An error occurred: {e}")