Uploading modified local folder struture

.streamlit/config.toml

@@ -0,0 +1,5 @@
+[server]
+enableXsrfProtection = false
+enableCORS = false
+maxUploadSize = 200
+gatherUsageStats = false

Dockerfile

@@ -1,20 +1,32 @@
-FROM python:3.13.5-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
+# Copy project files
+COPY requirements/requirements.txt ./requirements.txt
 COPY src/ ./src/
+COPY agent_plan_solve_app.py ./
+COPY agent_plan_solve/ ./agent_plan_solve/
+COPY config.py ./config.py
+COPY .streamlit /app/.streamlit
 
-RUN pip3 install -r requirements.txt
+
+
+# Install Python dependencies
+RUN pip3 install --upgrade pip && pip3 install -r requirements.txt
 
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+ENV STREAMLIT_SERVER_HEADLESS=true
+
+# Start the Streamlit app
+#CMD ["streamlit", "run", "agent_plan_solve_app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["streamlit", "run", "agent_plan_solve_app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]

README.md

@@ -4,14 +4,19 @@ emoji: 🚀
 colorFrom: red
 colorTo: red
 sdk: docker
+app_file: agent_plan_solve_app.py
 app_port: 8501
 tags:
-- streamlit
+  - streamlit
+  - agentic-ai
+  - wikipedia
+  - strategic-planning
 pinned: false
 short_description: AI planner using Wikipedia, ArXiv, Duck-search & Calculator
+startup_duration_timeout: 1h
 ---
 
-# Welcome to Streamlit!
+
 
 Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
 

agent_plan_solve/graph/build_graph.py

@@ -0,0 +1,27 @@
+# agent_plan_solve/graph/graph.py
+
+from langgraph.graph import StateGraph, START, END
+from agent_plan_solve.graph.state import PlanState
+from  agent_plan_solve.graph.nodes import (
+    _build_initial_plan,
+    _run_step,
+    _get_final_response,
+    _should_continue
+)
+
+__all__ = ["graph"]
+print("✅ build_graph.py loaded")
+
+# Build the LangGraph
+builder = StateGraph(PlanState)
+
+builder.add_node("initial_plan", _build_initial_plan)
+builder.add_node("run", _run_step)
+builder.add_node("response", _get_final_response)
+
+builder.add_edge(START, "initial_plan")
+builder.add_edge("initial_plan", "run")
+builder.add_conditional_edges("run", _should_continue)
+builder.add_edge("response", END)
+
+graph = builder.compile()

agent_plan_solve/graph/nodes.py

@@ -0,0 +1,96 @@
+# agent_plan_solve/graph/nodes.py
+
+from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
+from langgraph.prebuilt import create_react_agent
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from  agent_plan_solve.graph.state import Plan, PlanState
+from agent_plan_solve.utils.llm_config import get_openai_llm
+from agent_plan_solve.tools.calculator import calculator_tool
+from langchain.agents import load_tools
+from typing import Literal
+
+# Load LLM
+llm = get_openai_llm()
+
+# Planner prompt
+planner_prompt = ChatPromptTemplate.from_messages([
+    ("system", 
+     "For the given task, come up with a step-by-step plan.\n"
+     "Each step should be self-contained and lead to the final answer.\n"
+     "Avoid superfluous steps."),
+    ("user", "Prepare a plan to solve the following task:\n{task}\n")
+])
+
+planner = planner_prompt | llm.with_structured_output(Plan)
+
+# Toolset
+tools = load_tools(
+    tool_names=["ddg-search", "arxiv", "wikipedia"],
+    llm=llm
+) + [calculator_tool]
+
+# Execution agent prompt
+step_prompt = ChatPromptTemplate.from_messages([
+    ("system", 
+     "You're a smart assistant that carefully helps solve complex tasks.\n"
+     "Use tools to verify facts, compute results, and avoid assumptions."),
+    ("user", 
+     "TASK:\n{task}\n\nPLAN:\n{plan}\n\nSTEP TO EXECUTE:\n{step}\n")
+])
+
+class StepState(AgentState):
+    task: str
+    plan: str
+    step: str
+
+execution_agent = create_react_agent(
+    model=llm,
+    tools=tools,
+    state_schema=StepState,
+    prompt=step_prompt
+)
+
+# Final response prompt
+final_prompt = PromptTemplate.from_template(
+    "You're a helpful assistant that has executed a plan.\n"
+    "Given the results, prepare the final response.\n"
+    "TASK:\n{task}\n\nPLAN WITH RESULTS:\n{plan}\nFINAL RESPONSE:\n"
+)
+
+# Utility functions
+def get_current_step(state: PlanState) -> int:
+    return len(state.get("past_steps", []))
+
+def get_full_plan(state: PlanState) -> str:
+    full_plan = []
+    for i, step in enumerate(state["plan"].steps):
+        full_step = f"# {i+1}. Planned step: {step}\n"
+        if i < get_current_step(state):
+            full_step += f"Result: {state['past_steps'][i]}\n"
+        full_plan.append(full_step)
+    return "\n".join(full_plan)
+
+# Node functions
+async def _build_initial_plan(state: PlanState) -> PlanState:
+    plan = await planner.ainvoke(state["task"])
+    return {"plan": plan}
+
+async def _run_step(state: PlanState) -> PlanState:
+    plan = state["plan"]
+    current_step = get_current_step(state)
+    step = await execution_agent.ainvoke({
+        "plan": get_full_plan(state),
+        "step": plan.steps[current_step],
+        "task": state["task"]
+    })
+    return {"past_steps": [step["messages"][-1].content]}
+
+async def _get_final_response(state: PlanState) -> PlanState:
+    final_response = await (final_prompt | llm).ainvoke({
+        "task": state["task"],
+        "plan": get_full_plan(state)
+    })
+    return {"final_response": final_response}
+
+def _should_continue(state: PlanState) -> Literal["run", "response"]:
+    return "run" if get_current_step(state) < len(state["plan"].steps) else "response"

agent_plan_solve/graph/state.py

@@ -0,0 +1,15 @@
+# agent_plan_solve/graph/state.py
+
+from typing import Annotated, TypedDict
+import operator
+from pydantic import BaseModel, Field
+
+class Plan(BaseModel):
+    """Plan to follow in future"""
+    steps: list[str] = Field(..., description="Different steps to follow, in sorted order")
+
+class PlanState(TypedDict):
+    task: str
+    plan: Plan
+    past_steps: Annotated[list[str], operator.add]
+    final_response: str

agent_plan_solve/tools/calculator.py

@@ -0,0 +1,42 @@
+# agent_plan_solve/tools/calculator.py
+
+from pydantic import BaseModel, Field
+from langchain_core.runnables import RunnableLambda, RunnableConfig
+from langchain_core.tools import ToolException
+import numexpr as ne
+
+# Custom exception for calculator errors
+class CalculatorToolException(ToolException):
+    def __init__(self, message: str, expression: str):
+        super().__init__(f"[Calculator Error] {message} | Expression: '{expression}'")
+
+# Input schema for the calculator tool
+class CalculatorArgs(BaseModel):
+    expression: str = Field(..., description="Mathematical expression to be evaluated")
+
+# Core calculator logic
+def calculator(state: CalculatorArgs, config: RunnableConfig) -> str:
+    expression = state["expression"]
+    math_constants = config["configurable"].get("math_constants", {})
+
+    try:
+        result = ne.evaluate(expression.strip(), local_dict=math_constants)
+        return str(result)
+    except Exception as e:
+        raise CalculatorToolException(str(e), expression)
+
+# Wrap with retry logic
+calculator_with_retry = RunnableLambda(calculator).with_retry(
+    wait_exponential_jitter=True,
+    stop_after_attempt=3,
+)
+
+# Convert to LangChain-compatible tool
+calculator_tool = calculator_with_retry.as_tool(
+    name="calculator",
+    description=(
+        "Calculates a single mathematical expression, incl. complex numbers.\n"
+        "Always add * to operations, examples:\n73i -> 73*i\n7pi**2 -> 7*pi**2"
+    ),
+    args_schema=CalculatorArgs
+)

agent_plan_solve/utils/llm_config.py

@@ -0,0 +1,23 @@
+# agent_plan_solve/utils/llm_config.py
+
+import os
+from config import set_environment
+from langchain_openai import ChatOpenAI
+
+# Load environment variables from .env
+set_environment()
+
+class ChatOpenAIWrapper(ChatOpenAI):
+    def __init__(self, model_name="gpt-5-nano", **kwargs):
+        super().__init__(
+            model=model_name,
+            api_key=os.getenv("OPENAI_API_KEY"),
+            **kwargs
+        )
+
+def get_openai_llm(model_name="gpt-5-nano", streaming=True, **kwargs):
+    return ChatOpenAIWrapper(
+        model_name=model_name,
+        streaming=streaming,
+        **kwargs
+    )

agent_plan_solve_app.py

@@ -0,0 +1,62 @@
+import streamlit as st
+import asyncio
+import os
+import sys
+
+# ✅ Must be first Streamlit call
+st.set_page_config(page_title="Strategic Planner", layout="centered")
+
+# ─────────────────────────────────────────────
+# 📦 Environment & Path Setup
+# ─────────────────────────────────────────────
+project_root = os.path.join(os.getcwd(), "agent_plan_solve")
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+from config import set_environment
+set_environment()
+
+# ─────────────────────────────────────────────
+# 🧠 LangGraph Agent Import
+# ─────────────────────────────────────────────
+from agent_plan_solve.graph.build_graph import graph
+
+# ─────────────────────────────────────────────
+# 🎛️ Streamlit UI
+# ─────────────────────────────────────────────
+st.title("🧠Planner & Research Analyst  with GPT-5 Nano")
+st.markdown("Enter a task below and let the agent plan and execute it step-by-step.")
+task_input = st.text_area("Task:", placeholder="e.g. Write a strategic one-pager for building an AI startup")
+
+# ─────────────────────────────────────────────
+# 🔄 Async Agent Execution
+# ─────────────────────────────────────────────
+async def run_agent(task: str):
+    return await graph.ainvoke({"task": task})
+
+def display_response(response):
+    st.markdown("### ✅ Final Output")
+    if hasattr(response, "content"):
+        st.markdown(response.content)
+    elif isinstance(response, str):
+        st.markdown(response)
+    elif isinstance(response, dict) and "content" in response:
+        st.markdown(response["content"])
+    else:
+        st.error("No response generated.")
+
+# ─────────────────────────────────────────────
+# 🚀 Trigger Agent
+# ─────────────────────────────────────────────
+if st.button("Run Agent"):
+    if not task_input.strip():
+        st.warning("Please enter a task.")
+    else:
+        with st.spinner("Running LangGraph agent..."):
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                result = loop.run_until_complete(run_agent(task_input))
+                display_response(result.get("final_response"))
+            except Exception as e:
+                st.error(f"❌ Agent execution failed: {e}")

config.py

@@ -0,0 +1,30 @@
+import os
+from dotenv import load_dotenv
+
+def set_environment(verbose=True) -> dict:
+    env_path = os.path.abspath(".env")
+
+    # Load .env only if it exists
+    if os.path.exists(env_path):
+        load_dotenv(dotenv_path=env_path, override=True)
+        if verbose:
+            print(f"✅ Loaded .env from: {env_path}")
+    else:
+        if verbose:
+            print("⚠️ No .env file found. Relying on system environment variables.")
+
+    required_keys = [
+        "OPENAI_API_KEY",
+        "OPENROUTER_API_KEY",
+        "GEMINI_API_KEY",
+        "GROQ_API_KEY"
+    ]
+    missing_keys = [key for key in required_keys if not os.getenv(key)]
+
+    if verbose:
+        if missing_keys:
+            print(f"⚠️ Missing environment variables: {missing_keys}")
+        else:
+            print("✅ All required API keys loaded successfully!")
+
+    return {key: os.getenv(key) for key in required_keys}

requirements.txt

@@ -1,3 +0,0 @@
-altair
-pandas
-streamlit

requirements/requirements.txt

@@ -0,0 +1,52 @@
+# ───────── Core LangChain Stack ─────────
+langchain==0.3.17
+langchain-core>=0.3.67,<0.4.0
+langchain-community==0.3.16
+langchain-openai==0.3.19
+langchain-anthropic==0.3.5
+langchain-google-genai==2.0.0
+langchain-google-vertexai==2.0.28
+langchain-huggingface==0.3.1
+langchain-groq==0.2.4
+langchain-ollama==0.2.3
+langchain-mistralai==0.2.6
+langchain-chroma==0.2.2
+langchain-text-splitters==0.3.5
+langchain-experimental==0.3.4
+langgraph==0.3.34
+langsmith>=0.3.45,<0.4.0
+
+# ───────── Embeddings & Transformers ─────────
+sentence-transformers>=2.6.1
+transformers>=4.40.0
+huggingface-hub>=0.33.4,<0.40.0
+
+
+# ───────── Retrieval & Search ─────────
+duckduckgo_search==8.0.4
+arxiv==2.1.3
+wikipedia==1.4.0
+rank_bm25==0.2.2
+datasets==3.4.0
+
+# ───────── UI & Dev Tools ─────────
+streamlit==1.37.1
+ruff==0.9.4
+altair>=5.4.0
+python-dotenv
+
+# ───────── Document Loaders and document processors ─────────
+docarray==0.41.0
+pypdf
+python-docx
+unstructured
+beautifulsoup4
+html2text
+nltk
+
+# ───────── Infra & Orchestration ─────────
+ray==2.43.0
+
+#other libraries
+pydantic
+typing