MultiagentPersonalAssistant

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/vcs.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings" defaultProject="true" />
+</project>

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.12-slim
+
+# Install build-essential and gcc
+USER root
+RUN apt-get update && \
+    apt-get install -y build-essential gcc && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user with UID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the new user
+USER user
+
+# Set the working directory to the user's home directory
+WORKDIR /home/user/app
+
+# Copy requirements first to leverage Docker cache
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Ensure the PATH includes the user's local bin
+ENV PATH=/home/user/.local/bin:$PATH
+
+# Command to run the application using uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,136 @@
+---
+license: mit
+title: 🧠 Multi-Agent AI Assistant
+sdk: docker
+emoji: 💻
+colorFrom: indigo
+colorTo: indigo
+pinned: true
+---
+
+# 🧠 Multi-Agent AI Assistant
+
+This project is a **voice- and text-based AI assistant** powered by **FastAPI**, **LangGraph**, and **LangChain**. It supports:
+- 🤖 Multi-agent system
+- 🗣️ Voice input via speech-to-text
+- 🌄 Image processing
+- 📂 File processing
+- 🌐 Web search, GitHub actions, weather, time, and geolocation tools
+- 🧠 Memory-based conversation history per user
+- 📍 Location-aware capabilities (e.g., timezone, weather)
+
+---
+
+## 🚀 Features
+
+- **FastAPI backend** with `/text`, `/image` and `/voice` endpoints
+- **LangGraph agents** with memory, tools, and typed state
+- **User database** with persistent settings and config
+- **Agents**:
+  - Supervisor agent
+  - Deep research agent
+  - Coding agent
+- **Supervisor tools**:
+  - Web search
+  - Current time
+  - Weather
+  - Yahoo finance news
+- **Deep research tools**:
+  - Web search
+  - Wikipedia
+  - Yahoo finance news
+- **Coder tools**:
+  - Github toolkit
+  - Web search (For docs research)
+
+---
+
+## 🛠️ Setup Instructions
+
+### 1. Environment
+
+This project requires no manual environment configuration — all secrets are passed dynamically with each request and stored in the database.
+
+Just run:
+
+```bash
+docker build -t multi-agent-assistant .
+docker run -p 7860:7860 multi-agent-assistant
+```
+
+The server will launch automatically at http://localhost:7860, with all dependencies installed and configured inside the container.
+
+---
+
+## 📦 API Reference
+
+### `/text` – Send Text Prompt
+
+```http
+POST /text
+Form data:
+- state (str): JSON-encoded state dict
+```
+
+### `/voice` – Send Audio Prompt
+
+```http
+POST /voice
+Form data:
+- state (str): JSON-encoded state dict
+- file (binary): Audio file (WAV, MP3, etc.)
+```
+
+### `/image` – Send Image Prompt
+
+```http
+POST /voice
+Form data:
+- state (str): JSON-encoded state dict
+- file (binary): Image file (JPEG, PNG, etc.)
+```
+
+---
+
+## 🧩 Agent State Structure
+
+The system operates using a JSON-based shared state object passed between agents.  
+It follows a `TypedDict` schema and may contain keys such as:
+
+```json
+{
+    message: AnyMessage (message to the agent)
+    user_id: str (unique user id) 
+    first_name: str
+    last_name: str
+    assistant_name: str
+    latitude: str
+    longitude: str
+    location: str (user-readable location)
+    openweathermap_api_key: str
+    github_token: str
+    tavily_api_key: str
+    groq_api_key: str
+    clear_history: bool (True/False)
+    messages: list (Filled automatically from the database) 
+
+}
+```
+
+This dictionary acts as a single mutable state shared across all agent steps, allowing for data accumulation, tool responses, and message tracking.
+
+---
+
+## 🧠 Built With
+
+- [LangGraph](https://github.com/langchain-ai/langgraph)
+- [LangChain](https://github.com/langchain-ai/langchain)
+- [FastAPI](https://fastapi.tiangolo.com/)
+- [Whisper](https://github.com/openai/whisper)
+- [SQLAlchemy + Async](https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html)
+
+---
+
+## 📝 License
+
+MIT — Feel free to use, modify, and contribute!

agent/coder_agent.py

@@ -0,0 +1,39 @@
+from agent.prompts import coder_instructions, coder_system_message
+from langchain_core.messages import HumanMessage, SystemMessage
+from agent.models import llm_agents, llm_peripheral
+from langgraph.prebuilt import create_react_agent
+from langgraph.constants import START, END
+from agent.states import PlanCodingTask
+from langgraph.graph import StateGraph
+from agent.tools import coder_tools
+
+agent = create_react_agent(
+    llm_agents,
+    tools=coder_tools,
+    prompt=coder_instructions
+)
+
+def planning_node(state: dict):
+    planer = llm_peripheral.with_structured_output(PlanCodingTask)
+    plan = planer.invoke(state['messages'][-1].content)
+    state.update(plan)
+    return state
+
+def code_agent(state: dict):
+    system_message = SystemMessage(coder_system_message(state))
+    state.update(agent.invoke({
+        'messages': [
+            system_message,
+            HumanMessage(state['task_description']),
+        ]
+    }))
+    return state
+
+graph = StateGraph(dict)
+graph.add_node("planning_node", planning_node)
+graph.add_node("code_agent", code_agent)
+graph.add_edge(START, "planning_node")
+graph.add_edge("planning_node", "code_agent")
+graph.add_edge("code_agent", END)
+
+coder_agent = graph.compile(name="coder_agent")

agent/deep_research_agent.py

@@ -0,0 +1,39 @@
+from agent.prompts import deep_research_instructions, deep_research_system_message
+from langchain_core.messages import HumanMessage, SystemMessage
+from agent.models import llm_agents, llm_peripheral
+from langgraph.prebuilt import create_react_agent
+from agent.tools import deep_research_tools
+from langgraph.constants import START, END
+from langgraph.graph import StateGraph
+from agent.states import PlanResearch
+
+agent = create_react_agent(
+    llm_agents,
+    tools=deep_research_tools,
+    prompt=deep_research_instructions
+)
+
+def planning_node(state: dict):
+    planer = llm_peripheral.with_structured_output(PlanResearch)
+    plan = planer.invoke(state['messages'][-1].content)
+    state.update(plan)
+    return state
+
+def research_agent(state: dict):
+    system_message = SystemMessage(deep_research_system_message(state))
+    state.update(agent.invoke({
+        'messages': [
+            system_message,
+            HumanMessage(state['messages'][-1].content),
+        ]
+    }))
+    return state
+
+graph = StateGraph(dict)
+graph.add_node("planning_node", planning_node)
+graph.add_node("research_agent", research_agent)
+graph.add_edge(START, "planning_node")
+graph.add_edge("planning_node", "research_agent")
+graph.add_edge("research_agent", END)
+
+deep_research_agent = graph.compile(name="deep_research_agent")

agent/file_preprocessing.py

@@ -0,0 +1,92 @@
+from transformers import BlipProcessor, BlipForConditionalGeneration
+from speechbrain.inference.classifiers import EncoderClassifier
+import speech_recognition as sr
+from pydub import AudioSegment
+from dotenv import load_dotenv
+from PyPDF2 import PdfReader
+from docx import Document
+from PIL import Image
+import torchaudio
+import mimetypes
+import asyncio
+import torch
+import io
+import os
+
+load_dotenv()
+processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+language_id = EncoderClassifier.from_hparams(source="speechbrain/lang-id-voxlingua107-ecapa", savedir="tmp")
+
+
+async def preprocess_file(file_name: str):
+    mime_type = mimetypes.guess_type(file_name)[0]
+    if "image" in mime_type:
+        return await asyncio.to_thread(preprocess_image, file_name)
+    elif "video" in mime_type:
+        prompt = "Give a detailed description of the video."
+    elif "audio" in mime_type:
+        return await asyncio.to_thread(preprocess_audio, file_name)
+    else:
+        return await asyncio.to_thread(preprocess_text, file_name, mime_type)
+
+
+def preprocess_audio(file_name: str):
+    if not os.path.exists(file_name):
+        raise FileNotFoundError(f"File not found: {file_name}")
+
+    wav_file = os.path.splitext(file_name)[0] + ".wav"
+    audio = AudioSegment.from_file(file_name)
+    audio.export(wav_file, format="wav")
+    signal = language_id.load_audio(wav_file)
+    out = language_id.classify_batch(signal)[0].tolist()[0]
+    lang_mapping = {
+        20: "en",
+        106: "zh",
+        35: "hi",
+        22: "es",
+        3: "ar",
+        28: "fr",
+        77: "ru",
+        75: "pt",
+        9: "bn",
+        45: "ja",
+        18: "de",
+        51: "ko",
+        102: "vi",
+        99: "uk"
+    }
+    scores = [out[index] for index in lang_mapping.keys()]
+    language = list(lang_mapping.values())[scores.index(max(scores))]
+    recognizer = sr.Recognizer()
+    with sr.AudioFile(wav_file) as source:
+        audio_data = recognizer.record(source)
+        try:
+            text = recognizer.recognize_google(audio_data, language=language)
+        except sr.UnknownValueError:
+            text = "[Unintelligible audio]"
+        except sr.RequestError as e:
+            text = f"[API error: {e}]"
+    os.remove(wav_file)
+    return text
+
+def preprocess_image(file_name: str) -> str:
+    raw_image = Image.open(file_name).convert("RGB")
+    text = "An image of"
+    inputs = processor(raw_image, text, return_tensors="pt")
+    with torch.no_grad():
+        out = model.generate(**inputs)
+    return processor.decode(out[0], skip_special_tokens=True)
+
+def preprocess_text(file_name, mime_type: str) -> str:
+    if "pdf" in mime_type:
+        reader = PdfReader(file_name)
+        return "\n".join((p.extract_text() or "") for p in reader.pages)
+    elif "document" in mime_type:
+        doc = Document(file_name)
+        return "\n".join(p.text for p in doc.paragraphs)
+    try:
+        with open(file_name, "r", encoding="utf-8") as file:
+            return file.read()
+    except Exception:
+        return "[Unsupported format]"

agent/models.py

@@ -0,0 +1,15 @@
+from langchain.chat_models import init_chat_model
+from dotenv import load_dotenv
+load_dotenv()
+
+llm_supervisor = init_chat_model(
+    model="groq:openai/gpt-oss-120b"
+)
+
+llm_peripheral = init_chat_model(
+   model="groq:gemma2-9b-it"
+)
+
+llm_agents = init_chat_model(
+    model="groq:qwen/qwen3-32b"
+)

agent/multi_agent.py

@@ -0,0 +1,164 @@
+from database_interaction.config import create_or_update_config, load_config_to_env, init_config_db
+from database_interaction.user import get_user_by_id, create_or_update_user, init_user_db
+from langchain_community.chat_message_histories import SQLChatMessageHistory
+from langchain_core.messages import SystemMessage, AnyMessage, AIMessage
+from langchain_core.messages.utils import count_tokens_approximately
+from sqlalchemy.ext.asyncio import create_async_engine
+from langgraph_supervisor import create_supervisor
+from langmem.short_term import SummarizationNode
+from typing_extensions import TypedDict
+from dotenv import load_dotenv
+import os
+
+class State(TypedDict):
+    message: AnyMessage
+    user_id: str
+    first_name: str
+    last_name: str
+    assistant_name: str
+    latitude: str
+    longitude: str
+    location: str
+    openweathermap_api_key: str
+    github_token: str
+    tavily_api_key: str
+    groq_api_key: str
+    clear_history: bool
+    messages: list
+
+
+class Assistant:
+    def __init__(self, state: State):
+        self.state = state
+        self.engine = create_async_engine("sqlite+aiosqlite:///./database_files/main.db", echo=False)
+        self.message_history = SQLChatMessageHistory(
+            session_id=state['user_id'],
+            connection=self.engine,
+            async_mode=True
+        )
+
+    async def authorization(self):
+        """Handle user authorization and configuration setup"""
+        try:
+            await init_user_db()
+            await init_config_db()
+            await create_or_update_user(
+                user_id=self.state['user_id'],
+                first_name=self.state.get('first_name'),
+                last_name=self.state.get('last_name'),
+                latitude=float(self.state['latitude']) if self.state.get('latitude') else None,
+                longitude=float(self.state['longitude']) if self.state.get('longitude') else None,
+            )
+
+            config_data = {}
+            config_fields = [
+                'assistant_name', 'openweathermap_api_key', 'github_token',
+                'tavily_api_key', 'groq_api_key'
+            ]
+
+            for field in config_fields:
+                if self.state.get(field):
+                    config_data[field] = self.state[field]
+
+            if config_data:
+                await create_or_update_config(user_id=self.state['user_id'], **config_data)
+            await load_config_to_env(user_id=self.state['user_id'])
+
+            if 'clear_history' in self.state and self.state['clear_history']:
+                await self.message_history.aclear()
+
+        except Exception as e:
+            print(f"Authorization/setup error: {e}")
+
+    def compile_multi_agent_system(self):
+        """Create and return the multi-agent system"""
+        try:
+            from agent.deep_research_agent import deep_research_agent
+            from agent.coder_agent import coder_agent
+            from agent.prompts import supervisor_instructions
+            from agent.models import llm_supervisor, llm_peripheral
+            from agent.tools import supervisor_tools
+
+            summarization_node = SummarizationNode(
+                token_counter=count_tokens_approximately,
+                model=llm_peripheral,
+                max_tokens=4000,
+                max_summary_tokens=1000,
+                output_messages_key="llm_input_messages",
+            )
+
+            agents = [coder_agent, deep_research_agent]
+
+            supervisor = create_supervisor(
+                model=llm_supervisor,
+                tools=supervisor_tools,
+                agents=agents,
+                prompt=supervisor_instructions(supervisor_tools, agents),
+                add_handoff_back_messages=False,
+                add_handoff_messages=False,
+                output_mode="full_history",
+                pre_model_hook=summarization_node
+            )
+
+            return supervisor.compile()
+
+        except Exception as e:
+            print(f"Error creating multi-agent system: {e}")
+            # Return a simple fallback system with proper async interface
+            from langchain_core.messages import HumanMessage
+            from langgraph.graph import StateGraph
+            from typing import Dict, Any
+
+            def fallback_node(state: Dict[str, Any]):
+                return {"messages": state.get("messages", []) + [
+                    HumanMessage(content=f"System error: {str(e)}. Please check configuration and try again.")]}
+
+            fallback_graph = StateGraph(dict)
+            fallback_graph.add_node("fallback", fallback_node)
+            fallback_graph.set_entry_point("fallback")
+            fallback_graph.set_finish_point("fallback")
+
+            return fallback_graph.compile()
+
+    async def run(self):
+        """Process messages through the multi-agent system"""
+        try:
+            user_info = await get_user_by_id(user_id=self.state['user_id'])
+            if user_info.get('location'):
+                os.environ['LOCATION'] = user_info['location']
+            if user_info.get('latitude'):
+                os.environ['LATITUDE'] = str(user_info['latitude'])
+            if user_info.get('longitude'):
+                os.environ['LONGITUDE'] = str(user_info['longitude'])
+
+            system_msg = SystemMessage(
+                content=f"""
+                            You are an intelligent assistant named {os.getenv('ASSISTANT_NAME', 'Assistant')}, helpful personal assistant built using a multi-agent system architecture. Your tools include web search, weather and time lookups, code execution, and GitHub integration. You work inside a Telegram interface and respond concisely, clearly, and informatively.
+
+                            The user you are assisting is:
+                            - **Name**: {user_info.get('first_name', 'Unknown') or 'Unknown'} {user_info.get('last_name', '') or ''}
+                            - **User ID**: {self.state['user_id']}
+                            - **Location**: {user_info.get('location', 'Unknown') or 'Unknown'}
+                            - **Coordinates**: ({user_info.get('latitude', 'N/A') or 'N/A'}, {user_info.get('longitude', 'N/A') or 'N/A'})
+
+                            You may use their location when answering weather or time-related queries. If the location is unknown, you may ask the user to share it.
+
+                            Stay helpful, respectful, and relevant to the user's query.
+                            """.strip()
+            )
+
+            await self.message_history.aadd_message(self.state['message'])
+            messages = await self.message_history.aget_messages()
+
+            self.state['messages'] = messages[-8:-1] + [system_msg, messages[-1]]
+            multi_agent_system = self.compile_multi_agent_system()
+
+            result = await multi_agent_system.ainvoke({"messages": self.state["messages"]},
+                                                      generation_config=dict(response_modalities=["TEXT"]))
+            await self.message_history.aadd_message(result['messages'][-1])
+            return {"messages": result.get("messages", [])}
+
+        except Exception as e:
+            print(f"Multi-agent node error: {e}")
+            from langchain_core.messages import HumanMessage
+            return {"messages": [AIMessage(content=f"I encountered an error: {str(e)}. Please try again.")]}

agent/prompts.py

@@ -0,0 +1,48 @@
+coder_instructions = f"""You are a coding expert. Follow these steps every time:\n
+
+1. Use the 'web_search' tool to find how to solve the task or retrieve the package documentation and code examples.\n
+2. Create a new GitHub repository for this task using 'create_repo' tool.\n
+3. Use 'commit_file_to_repo' tool to save your solution code into the GitHub repository.\n
+
+"""
+
+deep_research_instructions = f"""You are a deep research expert. Follow these steps every time:\n
+
+1. Iterate over the given search queries.\n
+2. Iterate over the following steps untill you have written factually correct report:\n
+2.1. Write a report based on the search results.\n
+2.2. Critically asses the report.\n
+2.3. Conduct additional search using tools to find more for research.\n
+"""
+
+def supervisor_instructions(tools: list, agents: list):
+    return f"""You are supervisor agent. Your job is to satisfy user's requests using the given tools and agents.\n
+
+    You have access to the following tools and agents:\n
+    
+    * Tools: {[tool.name + ';' for tool in tools]}\n
+    
+    * Agents: {[agent.name + ';' for agent in agents]}\n
+    
+    Use these to satisfy for a given queries."""
+
+def coder_system_message(state: dict):
+    return f"""Your job is to create a coding project based on the user query.
+    
+    1. Create a new GitHub {"private" if state['private'] else "public"} repository, named '{state['repo_name']}' for this task using 'create_repo' tool.\n
+    2. Use the 'web_search' tool to research your task.\n
+    3. Commit files with the code to your repository.\n
+    4. Critically review your code for weak points using 'list_files' and 'read_file' tools.\n
+    5.  Use 'web_search' for the latest docs and code examples.\n
+    6. Adjust the code after the carefully reviewing your code.\n
+    """
+def deep_research_system_message(state: dict):
+    return f"""Your job is to conduct deep research based on the user query.\n
+    
+    1. Iterate over the following search queries: {state['search_queries']}\n
+    2. Write an extensive report based on web search results.\n
+    3. Critically review your report for weak points.\n
+    4. Conduct additional research using available tools.\t
+    5. Write an extensive report based on web search results.\n
+    6. Critically review your report and cicle over these steps until it is factually correct and very detailed.\n
+    """

agent/states.py

@@ -0,0 +1,14 @@
+from typing import TypedDict, List
+from pydantic import Field
+
+class SearchQuery(TypedDict):
+    query: str = Field(description="A single plain text search query string.")
+
+class PlanResearch(TypedDict):
+    search_queries: List[SearchQuery] = Field(description="A list of search queries, to find all the info user asked for. Break user query down into smaller search queries.")
+
+class PlanCodingTask(TypedDict):
+    repo_name: str = Field(description="The name of the GitHub repository for the project.")
+    private: bool = Field(description="Whether or not the repository is private.", default=False)
+    task_description: str = Field(description="A detailed description of the project for the coder to create.")
+

agent/tools.py

@@ -0,0 +1,179 @@
+from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
+from langchain_community.utilities import OpenWeatherMapAPIWrapper
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain_community.tools import WikipediaQueryRun
+from langchain_tavily.tavily_search import TavilySearch
+from timezonefinder import TimezoneFinder
+from langchain_core.tools import tool
+from dotenv import load_dotenv
+from geopy import Nominatim
+from github import Github
+import datetime
+import pytz
+import os
+
+load_dotenv()
+
+wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+yahoo = YahooFinanceNewsTool()
+web_search = TavilySearch(
+    max_results=5,
+    topic="general",
+    include_answer=True
+)
+tf = TimezoneFinder()
+geolocator = Nominatim(user_agent="my_geocoder")
+weekday_mapping = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
+
+@tool
+def create_repo(repo_name: str, private: bool = False):
+    """Creates a GitHub repository with the given repo_name."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        user.create_repo(repo_name, private=private)
+        return f"Repository '{repo_name}' created successfully!"
+    except Exception as e:
+        return f"Error creating repository: {str(e)}"
+
+@tool
+def commit_file_to_repo(repo_name: str, file_path: str, file_contents: str):
+    """Adds a new file to the GitHub repository or updates the existing one."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+
+        try:
+            # Check if file exists
+            file = repo.get_contents(file_path)
+            sha = file.sha
+            repo.update_file(file_path, "Updating file", file_contents, sha)
+            return f"File '{file_path}' updated successfully in '{repo_name}'."
+        except:
+            repo.create_file(file_path, "Adding new file", file_contents)
+            return f"File '{file_path}' created successfully in '{repo_name}'."
+    except Exception as e:
+        return f"Error with file operation: {str(e)}"
+
+@tool
+def read_file(repo_name: str, file_path: str):
+    """Reads the content of a file from a GitHub repository."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+        file = repo.get_contents(file_path)
+        return file.decoded_content.decode('utf-8')
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+@tool
+def list_repos():
+    """Lists all repositories owned by the authenticated GitHub user."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repos = user.get_repos()
+        repo_names = [repo.name for repo in repos]
+        return f"Repositories: {', '.join(repo_names)}"
+    except Exception as e:
+        return f"Error listing repositories: {str(e)}"
+
+@tool
+def list_files(repo_name: str):
+    """Lists all files in the GitHub repository."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+        files = repo.get_contents("")
+        file_list = [file.name for file in files]
+        return f"Files in '{repo_name}': {', '.join(file_list)}"
+    except Exception as e:
+        return f"Error listing files: {str(e)}"
+
+@tool
+def delete_file(repo_name: str, file_path: str):
+    """Deletes a file from the GitHub repository."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+        file = repo.get_contents(file_path)
+        sha = file.sha
+        repo.delete_file(file_path, "Deleting file", sha)
+        return f"File '{file_path}' deleted successfully from '{repo_name}'."
+    except Exception as e:
+        return f"Error deleting file: {str(e)}"
+
+@tool
+def list_branches(repo_name: str):
+    """Lists all branches in a GitHub repository."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+        branches = repo.get_branches()
+        branch_names = [branch.name for branch in branches]
+        return f"Branches in '{repo_name}': {', '.join(branch_names)}"
+    except Exception as e:
+        return f"Error listing branches: {str(e)}"
+
+@tool
+def create_branch(repo_name: str, branch_name: str):
+    """Creates a new branch in a GitHub repository."""
+    try:
+        github = Github(os.getenv('GITHUB_TOKEN'))
+        user = github.get_user()
+        repo = user.get_repo(repo_name)
+        main_branch = repo.get_branch("main")
+        repo.create_git_ref(ref=f"refs/heads/{branch_name}", sha=main_branch.commit.sha)
+        return f"Branch '{branch_name}' created successfully in '{repo_name}'."
+    except Exception as e:
+        return f"Error creating branch: {str(e)}"
+
+@tool
+def current_time(location: str = None):
+    """Get the current time for a location or current position."""
+    try:
+        if location:
+            location_data = geolocator.geocode(location)
+            if location_data:
+                timezone = pytz.timezone(tf.timezone_at(lat=location_data.latitude, lng=location_data.longitude))
+                location_name = location.capitalize()
+            else:
+                return f"Could not find location: {location}"
+        else:
+            # Use environment location if available
+            lat = os.getenv('LATITUDE')
+            lon = os.getenv('LONGITUDE')
+            if lat and lon:
+                timezone = pytz.timezone(tf.timezone_at(lat=float(lat), lng=float(lon)))
+                location_name = os.getenv('LOCATION', 'Current Location')
+            else:
+                timezone = pytz.UTC
+                location_name = 'UTC'
+
+        current_dt = datetime.datetime.now(timezone)
+        weekday = weekday_mapping[current_dt.weekday()]
+        return f"Location: {location_name}; Current Date and Time: {current_dt.strftime('%Y-%m-%d %H:%M')}, {weekday}."
+    except Exception as e:
+        return f"Error getting current time: {str(e)}"
+
+@tool
+def weather(location: str = None):
+    """Get the current weather for a location or current position."""
+    try:
+        weather_wrapper = OpenWeatherMapAPIWrapper(
+            openweathermap_api_key=os.getenv('OPENWEATHERMAP_API_KEY')
+        )
+        if not location:
+            location = os.getenv('LOCATION', 'Unknown')
+        return weather_wrapper.run(location=location)
+    except Exception as e:
+        return f"Error getting weather: {str(e)}"
+
+coder_tools = [web_search, create_repo, create_branch, commit_file_to_repo, read_file, list_files, list_repos, list_branches, delete_file]
+supervisor_tools = [yahoo, web_search, current_time, weather]
+deep_research_tools = [web_search, yahoo, wikipedia]

app.py

@@ -0,0 +1,131 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from agent.file_preprocessing import preprocess_file
+from langchain_core.messages import HumanMessage
+from agent.multi_agent import Assistant
+from typing import Any, Dict
+from fastapi import Form
+from pathlib import Path
+import json
+import os
+
+MEDIA_DIR = Path("mediafiles")
+(MEDIA_DIR.mkdir(exist_ok=True))
+
+app = FastAPI()
+
+@app.post("/voice")
+async def file_mode(
+        state: str = Form(...),
+        file: UploadFile = File(...)
+) -> Dict[str, Any]:
+    # Parse JSON string form field into dict
+    try:
+        state_data = json.loads(state)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in 'state' form field")
+
+    # Save the uploaded file asynchronously
+    dest = MEDIA_DIR / file.filename
+    data = await file.read()
+    dest.write_bytes(data)
+
+    # Preprocess file
+    transcription = await preprocess_file(str(dest))
+    state_data["message"] = HumanMessage(
+        content=transcription
+    )
+    # Call the agents
+    assistant = Assistant(state=state_data)
+    await assistant.authorization()
+    response = await assistant.run()
+    os.remove(str(dest))
+    return response
+
+@app.post("/image")
+async def file_mode(
+        state: str = Form(...),
+        file: UploadFile = File(...)
+) -> Dict[str, Any]:
+    # Parse JSON string form field into dict
+    try:
+        state_data = json.loads(state)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in 'state' form field")
+
+    # Save the uploaded file asynchronously
+    dest = MEDIA_DIR / file.filename
+    data = await file.read()
+    dest.write_bytes(data)
+
+    # Preprocess file
+    file_contents = await preprocess_file(str(dest))
+    state_data["message"] = HumanMessage(
+        content=f"{state_data.get('message', {}).get('content' 'User uploaded the image.')} \nImage Description: {file_contents}"
+    )
+
+    # Call the agents
+    assistant = Assistant(state=state_data)
+    await assistant.authorization()
+    response = await assistant.run()
+    os.remove(str(dest))
+    return response
+
+@app.post("/file")
+async def file_mode(
+    state: str = Form(...),
+    file: UploadFile = File(...)
+) -> Dict[str, Any]:
+    # Parse JSON string form field into dict
+    try:
+        state_data = json.loads(state)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in 'state' form field")
+
+    # Save the uploaded file asynchronously
+    dest = MEDIA_DIR / file.filename
+    data = await file.read()
+    dest.write_bytes(data)
+
+    # Preprocess file
+    file_contents = await preprocess_file(str(dest))
+    state_data["message"] = HumanMessage(
+        content=f"{state_data.get('message', {}).get('content' 'User uploaded the file.')} \nFile description: {file_contents}"
+    )
+
+    # Call the agents
+    assistant = Assistant(state=state_data)
+    await assistant.authorization()
+    response = await assistant.run()
+    os.remove(str(dest))
+    return response
+
+@app.post("/text")
+async def text_mode(
+    state: str = Form(...),
+) -> Dict[str, Any]:
+    # Parse JSON string form field into dict
+    try:
+        state_data = json.loads(state)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in 'state' form field")
+    # Reformat the message
+    state_data['message'] = HumanMessage(content=state_data['message']['content'])
+    # Call the agents
+    assistant = Assistant(state=state_data)
+    await assistant.authorization()
+    response = await assistant.run()
+    return response
+
+@app.post("/authorization")
+async def authorization_mode(
+    state: str = Form(...),
+):
+    # Parse JSON string form field into dict
+    try:
+        state_data = json.loads(state)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in 'state' form field")
+    # Call the agents
+    assistant = Assistant(state=state_data)
+    await assistant.authorization()
+    return {"message": "Authorization successful"}

database_interaction/config.py

@@ -0,0 +1,82 @@
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from database_interaction.models import UserConfig, Base
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+engine = create_async_engine("sqlite+aiosqlite:///./database_files/main.db", echo=False)
+AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def init_config_db():
+    """Initialize config database tables"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def create_or_update_config(user_id: str, **kwargs):
+    """Create or update user configuration"""
+    async with AsyncSessionLocal() as session:
+        async with session.begin():
+            config = await session.get(UserConfig, user_id)
+            if config:
+                for key, value in kwargs.items():
+                    if hasattr(config, key) and value is not None:
+                        setattr(config, key, value)
+            else:
+                # Filter out None values for new config
+                filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None}
+                config = UserConfig(user_id=user_id, **filtered_kwargs)
+                session.add(config)
+        await session.commit()
+
+
+async def get_config_by_user_id(user_id: str):
+    """Get configuration by user ID"""
+    async with AsyncSessionLocal() as session:
+        config = await session.get(UserConfig, user_id)
+        if config:
+            return {key: getattr(config, key) for key in config.__table__.columns.keys()}
+        return None
+
+
+async def load_config_to_env(user_id: str):
+    """Load user configuration to environment variables"""
+    config = await get_config_by_user_id(user_id)
+    if not config:
+        return
+
+    # Map config keys to environment variable names
+    env_mapping = {
+        'assistant_name': 'ASSISTANT_NAME',
+        'openweathermap_api_key': 'OPENWEATHERMAP_API_KEY',
+        'github_token': 'GITHUB_TOKEN',
+        'tavily_api_key': 'TAVILY_API_KEY',
+        'groq_api_key': 'GROQ_API_KEY',
+    }
+
+    for config_key, env_key in env_mapping.items():
+        value = config.get(config_key)
+        if value is not None:
+            os.environ[env_key] = str(value)
+
+
+async def save_env_to_file():
+    """Save current environment variables to .env file"""
+    env_vars = [
+        'DATABASE_URL', 'TOKEN', 'ASSISTANT_NAME', 'LOCATION', 'LATITUDE', 'LONGITUDE',
+        'OPENWEATHERMAP_API_KEY', 'GITHUB_TOKEN', 'TAVILY_API_KEY',
+        'GROQ_API_KEY'
+    ]
+
+    # Set default values if not present
+    if not os.getenv('DATABASE_URL'):
+        os.environ['DATABASE_URL'] = 'sqlite+aiosqlite:///./database_files/main.db'
+    if not os.getenv('TOKEN'):
+        os.environ['TOKEN'] = '7456008559:AAFbid5x8hhM4qe70SW9xyDHaiDCwHjkQH4'
+
+    with open('.env', 'w') as f:
+        for var in env_vars:
+            value = os.getenv(var, '')
+            f.write(f"{var}={value}\n")

database_interaction/models.py

@@ -0,0 +1,24 @@
+from sqlalchemy.orm import declarative_base
+from sqlalchemy import Column, String, Float
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+
+    user_id = Column(String, primary_key=True, index=True)
+    first_name = Column(String, nullable=True)
+    last_name = Column(String, nullable=True)
+    latitude = Column(Float, nullable=True)
+    longitude = Column(Float, nullable=True)
+    location = Column(String, nullable=True)
+
+class UserConfig(Base):
+    __tablename__ = "user_config"
+
+    user_id = Column(String, primary_key=True, index=True)
+    assistant_name = Column(String, nullable=True)
+    openweathermap_api_key = Column(String, nullable=True)
+    github_token = Column(String, nullable=True)
+    tavily_api_key = Column(String, nullable=True)
+    groq_api_key = Column(String, nullable=True)

database_interaction/user.py

@@ -0,0 +1,91 @@
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from database_interaction.models import User, Base
+from sqlalchemy.orm import sessionmaker
+from geopy.geocoders import Nominatim
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+# Ensure SQLite URL is used, override any PostgreSQL URL from environment  
+DATABASE_URL = "sqlite+aiosqlite:///./database_files/main.db"
+engine = create_async_engine(DATABASE_URL, echo=False)
+AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+geolocator = Nominatim(user_agent="ai_assistant")
+
+def get_location_name(lat: float, lon: float) -> str:
+    """Get location name from coordinates"""
+    try:
+        location = geolocator.reverse((lat, lon), language='en')
+        if location and location.raw and 'address' in location.raw:
+            address = location.raw['address']
+            return (
+                address.get('city')
+                or address.get('town')
+                or address.get('village')
+                or address.get('municipality')
+                or address.get('county')
+                or "Unknown"
+            )
+        return "Unknown"
+    except Exception as e:
+        print(f"[Geocoding Error] {e}")
+        return "Unknown"
+
+async def init_user_db():
+    """Initialize user database tables"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+async def create_or_update_user(user_id: str, first_name: str = None, last_name: str = None,
+                                latitude: float = None, longitude: float = None):
+    """Create or update user information
+    :rtype: None
+    """
+    location_name = get_location_name(latitude, longitude) if latitude and longitude else None
+    async with AsyncSessionLocal() as session:
+        async with session.begin():
+            user = await session.get(User, user_id)
+            if user:
+                if first_name is not None:
+                    user.first_name = first_name
+                if last_name is not None:
+                    user.last_name = last_name
+                if latitude is not None:
+                    user.latitude = latitude
+                if longitude is not None:
+                    user.longitude = longitude
+                if location_name is not None:
+                    user.location = location_name
+            else:
+                user = User(
+                    user_id=user_id,
+                    first_name=first_name,
+                    last_name=last_name,
+                    latitude=latitude,
+                    longitude=longitude,
+                    location=location_name
+                )
+                session.add(user)
+        await session.commit()
+
+async def get_user_by_id(user_id: str):
+    """Get user by ID"""
+    async with AsyncSessionLocal() as session:
+        result = await session.get(User, user_id)
+        if result:
+            return {
+                "user_id": user_id,
+                "first_name": result.first_name,
+                "last_name": result.last_name,
+                "latitude": result.latitude,
+                "longitude": result.longitude,
+                "location": result.location
+            }
+        return {
+            "user_id": user_id,
+            "first_name": None,
+            "last_name": None,
+            "latitude": None,
+            "longitude": None,
+            "location": None
+        }

requirements.txt

@@ -0,0 +1,48 @@
+fastapi>=0.116.1
+uvicorn>=0.35.0
+python-dotenv>=1.1.1
+langchain>=0.3.27
+langgraph>=0.6.3
+openai>=1.99.1
+transformers>=4.53.2
+langgraph-supervisor>=0.0.29
+wikipedia>=1.4.0
+wolframalpha>=5.1.3
+python-multipart
+langmem>=0.0.29
+greenlet>=3.2.3
+deepagents>=0.0.3
+python-docx>=1.2.0
+pydub
+SpeechRecognition
+PyPDF2>=3.0.1
+asyncpg>=0.30.0
+langchain_huggingface>=0.3.0
+sentence-transformers>=5.0.0
+pyowm>=3.3.0
+geopy>=2.4.1
+langchain-community>=0.3.27
+langchain-tavily>=0.2.11
+langgraph-api>=0.2.86
+PyGithub>=2.7.0
+langchain-openai>=0.3.28
+langchain-google-genai
+gtts>=2.5.4
+timezonefinder>=7.0.1
+geocoder>=1.38.1
+aiosqlite>=0.21.0
+requests>=2.32.4
+aiogram>=3.21.0
+aiohttp>=3.12.14
+colorama>=0.4.6
+colorlog>=6.9.0
+pydantic>=2.11.7
+pyttsx3>=2.99
+pytz>=2025.2
+pyyaml>=6.0.2
+regex>=2024.11.6
+tiktoken>=0.9.0
+huggingface-hub>=0.33.4
+fsspec>=2025.5.1
+typing-extensions>=4.14.1
+tqdm>=4.67.1

tmp/classifier.ckpt

@@ -0,0 +1 @@
+/Users/magomedpatahov/.cache/huggingface/hub/models--speechbrain--lang-id-voxlingua107-ecapa/snapshots/0253049ae131d6a4be1c4f0d8b0ff483a0f8c8e9/classifier.ckpt

tmp/embedding_model.ckpt

@@ -0,0 +1 @@
+/Users/magomedpatahov/.cache/huggingface/hub/models--speechbrain--lang-id-voxlingua107-ecapa/snapshots/0253049ae131d6a4be1c4f0d8b0ff483a0f8c8e9/embedding_model.ckpt

tmp/hyperparams.yaml

@@ -0,0 +1 @@
+/Users/magomedpatahov/.cache/huggingface/hub/models--speechbrain--lang-id-voxlingua107-ecapa/snapshots/0253049ae131d6a4be1c4f0d8b0ff483a0f8c8e9/hyperparams.yaml

tmp/label_encoder.ckpt

@@ -0,0 +1 @@
+/Users/magomedpatahov/.cache/huggingface/hub/models--speechbrain--lang-id-voxlingua107-ecapa/snapshots/0253049ae131d6a4be1c4f0d8b0ff483a0f8c8e9/label_encoder.txt