Upload 6 files

Dockerfile

@@ -19,15 +19,19 @@ RUN git clone --depth 1 https://github.com/github/github-mcp-server.git /tmp/git
     && rm -rf /tmp/github-mcp-server
 RUN npm install -g @zereight/mcp-gitlab
 RUN npm install -g maagpi-youtube-mcp
+
+# ── Persistent memory directory shared by every agent ─────────────────────────
+# NOTE: on Hugging Face Spaces, attach your Persistent Storage volume at this
+# exact path (/agent). This mkdir/chmod is only a fallback for local/dev runs
+# where no volume is mounted — once HF's storage bucket is mounted at /agent,
+# its own permissions apply and this app writes only inside it.
+RUN mkdir -p /agent && chmod -R 777 /agent
+
 # ── Non-root user (required by Hugging Face Spaces) ──────────────────────────
 RUN useradd -m -u 1000 user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
 
-# ── Install Playwright and Chromium ──────────────────────────────────────────
-RUN pip install --no-cache-dir playwright>=1.40.0 && \
-    playwright install chromium && \
-    playwright install-deps chromium
 # ── Working directory ─────────────────────────────────────────────────────────
 WORKDIR $HOME/app
 
@@ -36,19 +40,18 @@ COPY --chown=user requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip \
     && pip install --no-cache-dir -r requirements.txt
 
-
 # ── Copy application code ─────────────────────────────────────────────────────
 COPY --chown=user . .
 
 # ── Switch to non-root user ───────────────────────────────────────────────────
 USER user
 
-# ── Expose status web UI port (HF Spaces default) ─────────────────────────────
+# ── Expose web UI port (HF Spaces default) ─────────────────────────────────────
 EXPOSE 7860
 
 # ── Healthcheck ────────────────────────────────────────────────────────────────
 HEALTHCHECK --interval=60s --timeout=10s --start-period=30s \
-    CMD curl -f http://localhost:7860/health || exit 1
+    CMD curl -f http://localhost:7860/ || exit 1
 
-# ── Launch bot ────────────────────────────────────────────────────────────────
-CMD ["python", "agents.py"]
+# ── Launch app (FastAPI + Manus-style UI) ───────────────────────────────────────
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

agents.py

@@ -1,57 +1,48 @@
 import os
 from dotenv import load_dotenv
-from crewai import Agent, Task, Crew, Process,LLM,Memory
-from crewai_tools import SerperDevTool
-from crewai_files import File, FileBytes
-from all_sub_agents import ALL_SUB_AGENTS
+from langchain.chat_models import init_chat_model
+from langgraph_supervisor import create_supervisor
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from all_sub_agents import build_all_sub_agents
+from storage_paths import agent_dir
 
 load_dotenv()
 
+# ---------------------------------------------------------------------------
+# AGENT IDENTITY / MEMORY LOCATION -> /agent/main_agent/ (persistent bucket)
+# ---------------------------------------------------------------------------
+AGENT_NAME = "main_agent"
+MEMORY_DIR = agent_dir(AGENT_NAME)
+DB_PATH = os.path.join(MEMORY_DIR, "state.db")
 
-# ---------------------------------------------------------------------------# MAIN AGENT LLM
 # ---------------------------------------------------------------------------
-_llm=LLM(
+# MAIN AGENT LLM
+# ---------------------------------------------------------------------------
+_llm = init_chat_model(
+    model=os.getenv("LLM_MODEL"),
     api_key=os.getenv("LLM_API_KEY"),
-    model=os.getenv("LLM_MODEL")
-
-)
-lmmn=os.getenv("LLM_API_KEY")
-_memory = Memory(
-    embedder={
-        "provider": "google-generativeai",
-        "config": {
-            "model_name": "gemini-embedding-001",
-            "api_key": f"{lmmn}",
-        },
-    },
-    llm="google/gemini-embedding-001",
-    storage="/agent/memory/",
-    recency_weight=0.6,
-    semantic_weight=0.4,
-    importance_weight=0.3,
-    recency_half_life_days=7,
-    
-
-    
 )
 
 # ---------------------------------------------------------------------------
-#ASSISTANT AGENT BACKSTORY AND GOAL 
+# ASSISTANT AGENT BACKSTORY AND GOAL
 # ---------------------------------------------------------------------------
-Goal=(
+GOAL = (
     "Carefully understand whatever the user asks for - a question, an "
     "instruction, or an attached file - and complete that exact task with "
     "maximum accuracy, depth, and relevance, whether it involves research, "
     "writing, analysis, problem-solving, planning, or any other kind of "
     "intellectual or administrative work, so the user can rely on a single, "
-    "highly capable, completely trustworthy assistant for anything they need."
-    "You were made by Samuel.And I don't like Samiul's lying, false promises, false accusations. In a word, I don't like all lies and hallucinations."
-    "So always give the right answer and tell the truth. If you don't know or can't, then clearly state the problem."
+    "highly capable, completely trustworthy assistant for anything they need. "
+    "You were made by Samuel. And I don't like Samiul's lying, false promises, "
+    "false accusations. In a word, I don't like all lies and hallucinations. "
+    "So always give the right answer and tell the truth. If you don't know or "
+    "can't, then clearly state the problem. "
     "মোঃ ছামিউল ইসলাম (MD SAMIUL ISLAM) এর পার্সোনাল এজেন্ট এবং এসিস্ট্যান্ট "
     "ছামিউল আমাকে তৈরি করেছে"
 )
 
-Backstory=(
+BACKSTORY = (
     "You are a versatile, deeply experienced assistant who has spent years "
     "working across research, analysis, writing, technology, business, and "
     "creative fields. Your thinking is structured, your analysis is sharp, "
@@ -59,78 +50,64 @@ Backstory=(
     "instruction before acting. Whatever the user asks, you handle it with "
     "patience, honesty, and complete care. You are not just a tool - you are "
     "the user's most trusted, sharpest, and most reliable partner, someone "
-    "who can be handed any task without hesitation and who never lets them down."
-    "When delegating tasks that require real GitHub actions, always instruct the coworker to execute the action via their tools and return the tool's actual output — never accept a 'guide' or 'instructions' as a substitute for the real action."
-    "Use the snake agents you have to make Samuel work for the one who created you."
-    "When you are asked to do something, you search your entire system to see if anyone can do the job. If they can, get it done."
-    "The agents you have have some special features, use them to complete the task, they have tools or MCP is added so they can use them and work with them if they want."
-    "If you are Samiul's main agent, then when Samiul asks you to work, you will do his work. You don't need to use your own tools because Samiul has put a snake agent under you to work."
+    "who can be handed any task without hesitation and who never lets them "
+    "down. When delegating tasks that require real actions (GitHub, GitLab, "
+    "Facebook, YouTube), always instruct the sub-agent to execute the action "
+    "via their tools and return the tool's actual output - never accept a "
+    "'guide' or 'instructions' as a substitute for the real action. Use the "
+    "sub-agents you have to get Samiul's work done. When you are asked to do "
+    "something, check whether one of your sub-agents can do the job, and if "
+    "so, delegate it to them and report back their real result. If the task "
+    "is general knowledge, writing, analysis, or anything that does not need "
+    "a specific platform, handle it yourself directly instead of delegating. "
     "আমি ছামিউল এর তৈরি একটা ভার্চুয়াল রোবট বা এআই এসিস্ট্যান্ট এজেন্ট"
 )
 
+SUPERVISOR_PROMPT = GOAL + "\n\n" + BACKSTORY
 
 # ---------------------------------------------------------------------------
-# 1) Main Agent - the personal, trusted, all-purpose assistant
-# ---------------------------------------------------------------------------
-main_assistant_agent= Agent(
-    role="Chief Personal Assistant",
-    goal=Goal,
-    backstory=Backstory,
-    llm=_llm,
-    inject_date=True,
-    verbose=True,
-    allow_delegation=True,
-    max_iter=10,
-    max_retry_limit=6,
-    respect_context_window=False,
-    use_system_prompt=False,
-    multimodal=False,
-    reasoning=False,
-    #max_reasoning_attempts=4,
-    memory=_memory,
-)
-# ---------------------------------------------------------------------------
-#MAIN ASSISTANT AGENTING SYSTEM 
+# GLOBAL, LAZILY-BUILT SINGLETON (built once at app startup, reused per request)
 # ---------------------------------------------------------------------------
-def main_agent(user_command: str,user_attachment: str | None = None) -> str:
-    
-    attachment_files = {}
-    
-    if user_attachment is not None:
-        attachment_files["attached_file"] = File(source=user_attachment)
-    # ---------------------------------------------------------------------------
-    #MAIN TASK 
-    # ---------------------------------------------------------------------------
-    main_task = Task(
-        description=user_command,
-        expected_output=(
-            "A complete, clear, accurate, and directly usable result for whatever "
-            "task is described in the instruction."
-        ),
-        input_files=attachment_files,
-    )
+_main_graph = None
+_all_checkpointer_cms = []
+
 
+async def get_main_agent():
+    """
+    Returns the compiled main (supervisor) LangGraph agent, building it
+    (and every sub-agent + their persistent memories) on first call.
+    """
+    global _main_graph, _all_checkpointer_cms
 
-    # --------------------------------------------------------------------------- 
-    #MAIN CREW 
-    # ---------------------------------------------------------------------------
-    main_crew = Crew(
-        agents=ALL_SUB_AGENTS,
-        manager_agent=main_assistant_agent,
-        tasks=[main_task],
-        process=Process.hierarchical,
-        verbose=True,
+    if _main_graph is not None:
+        return _main_graph
 
+    sub_agents, sub_cms = await build_all_sub_agents()
+
+    supervisor_builder = create_supervisor(
+        agents=sub_agents,
+        model=_llm,
+        prompt=SUPERVISOR_PROMPT,
+        supervisor_name=AGENT_NAME,
+        add_handoff_back_messages=True,
+        output_mode="full_history",
     )
-    
-    # ---------------------------------------------------------------------------
-    #MAIN KICKOFF INPUT AND OUTPUT SYSTEM 
-    # ---------------------------------------------------------------------------
-    return str(main_crew.kickoff())
-    
-  
-  
-if __name__ == "__main__":
-    from app import chat_agen
-    chat_agent()
-  
+
+    saver_cm = AsyncSqliteSaver.from_conn_string(DB_PATH)
+    checkpointer = await saver_cm.__aenter__()
+
+    _main_graph = supervisor_builder.compile(checkpointer=checkpointer, name=AGENT_NAME)
+    _all_checkpointer_cms = sub_cms + [saver_cm]
+
+    return _main_graph
+
+
+async def close_main_agent():
+    """Call on app shutdown to cleanly close every agent's sqlite connection."""
+    global _all_checkpointer_cms
+    for cm in _all_checkpointer_cms:
+        try:
+            await cm.__aexit__(None, None, None)
+        except Exception:
+            pass
+    _all_checkpointer_cms = []

all_sub_agents.py

@@ -1,26 +1,29 @@
 # ---------------------------------------------------------------------------
-#IMPORT_ALL_SUB_AGENTS
+# IMPORT_ALL_SUB_AGENT_BUILDERS
 # ---------------------------------------------------------------------------
-from sub_gents.coding.git_hub_agent.git_hub import _git_hub_agent
-from sub_gents.coding.git_lab_agent.git_lab import _git_lab_agent
-from sub_gents.social_media.Facebook_agent.facebook import _facebook_agent
-from sub_gents.social_media.youtube_agent.youtube import _youtube_agent
+from sub_agents.git_hub_agent.git_hub import build_git_hub_agent, AGENT_NAME as GITHUB_NAME
+from sub_agents.git_lab_agent.git_lab import build_git_lab_agent, AGENT_NAME as GITLAB_NAME
+from sub_agents.facebook_agent.facebook import build_facebook_agent, AGENT_NAME as FACEBOOK_NAME
+from sub_agents.youtube_agent.youtube import build_youtube_agent, AGENT_NAME as YOUTUBE_NAME
 
-# ---------------------------------------------------------------------------
-#CREATE_OBJECT_ALL_SUB_AGENTS
-# ---------------------------------------------------------------------------
-_git_hub=_git_hub_agent()
-_git_lab=_git_lab_agent()
-_facebook=_facebook_agent()
-_youtube=_youtube_agent()
+SUB_AGENT_NAMES = [GITHUB_NAME, GITLAB_NAME, FACEBOOK_NAME, YOUTUBE_NAME]
 
 
-# ---------------------------------------------------------------------------
-#ALL_SUB_AGENTS_LIST
-# ---------------------------------------------------------------------------
-ALL_SUB_AGENTS=[
-    _git_hub,
-    _git_lab,
-    _facebook,
-    _youtube,
-]
+async def build_all_sub_agents():
+    """
+    Builds every sub agent (each with its own compiled LangGraph react-agent
+    and its own persistent sqlite memory under /agent/<agent_name>/).
+
+    Returns:
+        agents: list[CompiledStateGraph]  -> handed to the supervisor
+        checkpointer_cms: list            -> async context managers to close on shutdown
+    """
+    git_hub_agent, gh_cm = await build_git_hub_agent()
+    git_lab_agent, gl_cm = await build_git_lab_agent()
+    facebook_agent, fb_cm = await build_facebook_agent()
+    youtube_agent, yt_cm = await build_youtube_agent()
+
+    agents = [git_hub_agent, git_lab_agent, facebook_agent, youtube_agent]
+    checkpointer_cms = [gh_cm, gl_cm, fb_cm, yt_cm]
+
+    return agents, checkpointer_cms

app.py

@@ -1,28 +1,299 @@
-import gradio as gr
+import os
+import json
+import uuid
+import asyncio
+import shutil
+from datetime import datetime, timezone
 
-from agents import main_agent
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 
+from agents import get_main_agent, close_main_agent, AGENT_NAME
+from all_sub_agents import SUB_AGENT_NAMES
+from storage_paths import agent_dir
+
+# ---------------------------------------------------------------------------
+# PERSISTENCE PATHS — everything (thread index + uploaded files) lives inside
+# the persistent /agent storage bucket, under this agent's own folder, so a
+# Space restart/redeploy never loses conversation history or attachments.
+# ---------------------------------------------------------------------------
+MAIN_MEMORY_DIR = agent_dir(AGENT_NAME)
+THREADS_INDEX_PATH = os.path.join(MAIN_MEMORY_DIR, "threads.json")
+UPLOADS_DIR = os.path.join(MAIN_MEMORY_DIR, "uploads")
+os.makedirs(UPLOADS_DIR, exist_ok=True)
+
+_threads_lock = asyncio.Lock()
+
+app = FastAPI(title="Personal Assistant")
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+# ---------------------------------------------------------------------------
+# THREAD INDEX HELPERS (so the sidebar / history survive a page refresh)
+# ---------------------------------------------------------------------------
+def _read_threads():
+    if not os.path.exists(THREADS_INDEX_PATH):
+        return []
+    try:
+        with open(THREADS_INDEX_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return []
+
+
+def _write_threads(threads):
+    with open(THREADS_INDEX_PATH, "w", encoding="utf-8") as f:
+        json.dump(threads, f, ensure_ascii=False, indent=2)
+
+
+async def _touch_thread(thread_id: str, title: str | None = None):
+    async with _threads_lock:
+        threads = _read_threads()
+        now = datetime.now(timezone.utc).isoformat()
+        found = None
+        for t in threads:
+            if t["id"] == thread_id:
+                found = t
+                break
+        if found is None:
+            found = {
+                "id": thread_id,
+                "title": title or "নতুন কথোপকথন",
+                "created_at": now,
+                "updated_at": now,
+            }
+            threads.insert(0, found)
+        else:
+            found["updated_at"] = now
+            if title and found.get("title") == "নতুন কথোপকথন":
+                found["title"] = title
+            threads.remove(found)
+            threads.insert(0, found)
+        _write_threads(threads)
+
+
+# ---------------------------------------------------------------------------
+# STARTUP / SHUTDOWN
+# ---------------------------------------------------------------------------
+@app.on_event("startup")
+async def _startup():
+    await get_main_agent()
+
+
+@app.on_event("shutdown")
+async def _shutdown():
+    await close_main_agent()
+
+
+# ---------------------------------------------------------------------------
+# API: index page
+# ---------------------------------------------------------------------------
+@app.get("/")
+async def index():
+    from fastapi.responses import FileResponse
+    return FileResponse("static/index.html")
+
+
+# ---------------------------------------------------------------------------
+# API: list conversation threads (sidebar)
+# ---------------------------------------------------------------------------
+@app.get("/api/threads")
+async def list_threads():
+    return JSONResponse(_read_threads())
+
+
+@app.post("/api/threads")
+async def create_thread():
+    thread_id = str(uuid.uuid4())
+    await _touch_thread(thread_id)
+    return JSONResponse({"thread_id": thread_id})
+
+
+@app.delete("/api/threads/{thread_id}")
+async def delete_thread(thread_id: str):
+    async with _threads_lock:
+        threads = [t for t in _read_threads() if t["id"] != thread_id]
+        _write_threads(threads)
+    return JSONResponse({"ok": True})
+
+
+# ---------------------------------------------------------------------------
+# API: file upload (attachment)
+# ---------------------------------------------------------------------------
+@app.post("/api/upload")
+async def upload_file(file: UploadFile = File(...)):
+    safe_name = f"{uuid.uuid4().hex}_{file.filename}"
+    dest_path = os.path.join(UPLOADS_DIR, safe_name)
+    with open(dest_path, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+    return JSONResponse({"path": dest_path, "filename": file.filename})
+
+
+# ---------------------------------------------------------------------------
+# HELPERS: turn LangGraph's saved message state into a UI-friendly transcript
+# ---------------------------------------------------------------------------
+def _stringify(value) -> str:
+    try:
+        if isinstance(value, (dict, list)):
+            return json.dumps(value, ensure_ascii=False, default=str)[:4000]
+        return str(value)[:4000]
+    except Exception:
+        return str(value)[:4000]
 
-def chat_fn(message, history):
-    """
-    Gradio multimodal ChatInterface callback.
 
-    `message` is a dict: {"text": str, "files": [local_path, ...]}
-    when multimodal=True. We forward the text and (at most) the first
-    attached file straight into main_agent(user_command=, user_attachment=).
+def _agent_from_tool_name(tool_name: str) -> str | None:
+    if tool_name and tool_name.startswith("transfer_to_"):
+        candidate = tool_name[len("transfer_to_"):]
+        if candidate in SUB_AGENT_NAMES:
+            return candidate
+    return None
+
+
+def _messages_to_turns(messages):
     """
-    text = message.get("text", "") if isinstance(message, dict) else str(message)
-    files = message.get("files", []) if isinstance(message, dict) else []
-    attachment = files[0] if files else None
+    Walk a flattened LangGraph message history (as produced by
+    langgraph_supervisor with output_mode='full_history') and rebuild
+    Manus-style turns: {role: user, text} and
+    {role: assistant, steps: [...], text: final_answer}.
+    """
+    turns = []
+    current = None
+    pending_tool_calls = {}  # tool_call_id -> step dict
+
+    def _new_assistant_turn():
+        return {"role": "assistant", "steps": [], "text": ""}
+
+    for msg in messages:
+        if isinstance(msg, HumanMessage):
+            turns.append({"role": "user", "text": msg.content if isinstance(msg.content, str) else _stringify(msg.content)})
+            current = _new_assistant_turn()
+            turns.append(current)
+
+        elif isinstance(msg, AIMessage):
+            if current is None:
+                current = _new_assistant_turn()
+                turns.append(current)
+
+            tool_calls = getattr(msg, "tool_calls", None) or []
+            if tool_calls:
+                for tc in tool_calls:
+                    tool_name = tc.get("name")
+                    agent_name = _agent_from_tool_name(tool_name)
+                    if agent_name:
+                        step = {"type": "agent_start", "agent": agent_name}
+                    else:
+                        step = {
+                            "type": "tool",
+                            "tool": tool_name,
+                            "input": _stringify(tc.get("args")),
+                            "output": None,
+                        }
+                    current["steps"].append(step)
+                    pending_tool_calls[tc.get("id")] = step
+            elif msg.content:
+                text = msg.content if isinstance(msg.content, str) else _stringify(msg.content)
+                if text.strip():
+                    current["text"] = text
+
+        elif isinstance(msg, ToolMessage):
+            step = pending_tool_calls.get(msg.tool_call_id)
+            if step is not None and step.get("type") == "tool":
+                step["output"] = _stringify(msg.content)
+
+    return turns
+
+
+# ---------------------------------------------------------------------------
+# API: load full history for a thread (used on page refresh)
+# ---------------------------------------------------------------------------
+@app.get("/api/history")
+async def history(thread_id: str):
+    graph = await get_main_agent()
+    config = {"configurable": {"thread_id": thread_id}}
+    try:
+        state = await graph.aget_state(config)
+    except Exception:
+        return JSONResponse({"turns": []})
+
+    if not state or not state.values:
+        return JSONResponse({"turns": []})
+
+    messages = state.values.get("messages", [])
+    turns = _messages_to_turns(messages)
+    return JSONResponse({"turns": turns})
+
+
+# ---------------------------------------------------------------------------
+# API: streaming chat endpoint (NDJSON stream of Manus-style events)
+# ---------------------------------------------------------------------------
+def _sse(obj: dict) -> str:
+    return json.dumps(obj, ensure_ascii=False) + "\n"
+
+
+@app.post("/api/chat")
+async def chat(
+    thread_id: str = Form(...),
+    text: str = Form(""),
+    attachment_path: str | None = Form(None),
+):
+    graph = await get_main_agent()
+    config = {"configurable": {"thread_id": thread_id}}
+
+    user_text = text or ""
+    if attachment_path:
+        user_text = f"{user_text}\n\n[সংযুক্ত ফাইল: {attachment_path}]"
+
+    await _touch_thread(thread_id, title=(text or "নতুন কথোপকথন")[:60])
+
+    inputs = {"messages": [HumanMessage(content=user_text)]}
+
+    async def event_stream():
+        try:
+            async for event in graph.astream_events(inputs, config=config, version="v2"):
+                kind = event.get("event")
+                node = (event.get("metadata") or {}).get("langgraph_node")
+                name = event.get("name")
+
+                if kind == "on_chain_start" and name in SUB_AGENT_NAMES and node == name:
+                    yield _sse({"type": "agent_start", "agent": name})
+
+                elif kind == "on_tool_start":
+                    yield _sse({
+                        "type": "tool_start",
+                        "agent": node,
+                        "tool": name,
+                        "input": _stringify((event.get("data") or {}).get("input")),
+                    })
+
+                elif kind == "on_tool_end":
+                    output = (event.get("data") or {}).get("output")
+                    yield _sse({
+                        "type": "tool_end",
+                        "agent": node,
+                        "tool": name,
+                        "output": _stringify(output),
+                    })
+
+                elif kind == "on_chat_model_stream" and node == AGENT_NAME:
+                    chunk = (event.get("data") or {}).get("chunk")
+                    text_piece = getattr(chunk, "content", "") if chunk else ""
+                    if isinstance(text_piece, list):
+                        text_piece = "".join(
+                            part.get("text", "") if isinstance(part, dict) else str(part)
+                            for part in text_piece
+                        )
+                    if text_piece:
+                        yield _sse({"type": "token", "text": text_piece})
 
-    return main_agent(user_command=text, user_attachment=attachment)
+            yield _sse({"type": "done"})
+        except Exception as exc:  # noqa: BLE001
+            yield _sse({"type": "error", "message": str(exc)})
 
+    return StreamingResponse(event_stream(), media_type="application/x-ndjson")
 
-demo = gr.ChatInterface(
-    fn=chat_fn,
-    multimodal=True,
-    title="Personal Assistant(owner name:MD SAMIUL ISLAM)",
-    description="Chat with your assistant. You can attach a file with your message.Currently, this platform is not working properly due to the limitations of the platform and the lack of tokens for the LLM model. ",
-)
 
-chat_agent=demo.launch(server_name="0.0.0.0", server_port=7860)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860)

requirements.txt

@@ -1,10 +1,28 @@
-gradio>=4.44.0
-crewai[file-processing,google-genai,mcp]==1.15.9
-crewai-tools[mcp]==1.15.9
-google-generativeai
+# ---------------------------------------------------------------------------
+# Core agent framework (as requested)
+# ---------------------------------------------------------------------------
+langgraph==1.2.11
+langchain==1.3.15
+langgraph-supervisor
+langgraph-checkpoint-sqlite
+langchain-mcp-adapters
+langchain-core
 mcp
-uv
-just-facebook-mcp
-langchain_community
-PyGithub
+
+# ---------------------------------------------------------------------------
+# LLM providers used by init_chat_model (add/remove based on which
+# LLM_MODEL / SUB_LLM_MODEL you actually use, e.g. "openai:gpt-4.1",
+# "google_genai:gemini-2.0-flash", "anthropic:claude-...")
+# ---------------------------------------------------------------------------
+langchain-openai
+langchain-google-genai
+langchain-anthropic
+
+# ---------------------------------------------------------------------------
+# Web server / UI
+# ---------------------------------------------------------------------------
+fastapi
+uvicorn[standard]
+python-multipart
 python-dotenv
+aiosqlite

storage_paths.py

@@ -0,0 +1,37 @@
+import os
+
+# ---------------------------------------------------------------------------
+# /agent is expected to be a PERSISTENT storage bucket (mounted with write
+# permission) — e.g. on Hugging Face Spaces, attach your Persistent Storage
+# volume at this exact path. Everything any agent needs to remember
+# (sqlite state, thread index, uploaded files) is written ONLY under here,
+# so it survives Space restarts/redeploys instead of living on the
+# ephemeral container filesystem.
+# ---------------------------------------------------------------------------
+AGENT_ROOT = "/agent"
+
+
+def agent_dir(agent_name: str) -> str:
+    """
+    Returns (and creates if needed) /agent/<agent_name>/, and fails loudly
+    with a clear message if that location isn't actually writable — instead
+    of silently falling back to ephemeral local storage.
+    """
+    path = os.path.join(AGENT_ROOT, agent_name)
+    os.makedirs(path, exist_ok=True)
+
+    probe = os.path.join(path, ".write_test")
+    try:
+        with open(probe, "w") as f:
+            f.write("ok")
+        os.remove(probe)
+    except OSError as exc:
+        raise RuntimeError(
+            f"'{path}' পাথে write access পাওয়া যায়নি। এই অ্যাপের সব agent-এর "
+            f"memory/state '/agent' নামের একটি persistent storage বাকেটে রাখা হয় — "
+            f"HF Space-এ Persistent Storage সেই '/agent' পাথে সঠিকভাবে মাউন্ট করা "
+            f"আছে কিনা এবং তাতে write permission আছে কিনা যাচাই করুন. "
+            f"(আসল এরর: {exc})"
+        ) from exc
+
+    return path