origin

Dockerfile

@@ -0,0 +1,61 @@
+#Pull the base image
+FROM ghcr.io/danny-avila/librechat-dev:latest
+
+
+#FROM ghcr.io/danny-avila/librechat-dev:d3d7d11ea8cbeef9fdffa1eb45d6b866e6ee182b
+
+
+
+
+# Set environment variables
+ENV HOST=0.0.0.0
+ENV PORT=7860
+ENV SESSION_EXPIRY=900000
+ENV REFRESH_TOKEN_EXPIRY=604800000
+# ENV MEILI_NO_ANALYTICS=true
+# ENV MEILI_HOST=https://librechat-meilisearch.hf.space
+
+# Create necessary directories
+RUN mkdir -p /app/uploads/temp
+RUN mkdir -p /app/client/public/images/temp
+RUN mkdir -p /app/api/logs/
+RUN mkdir -p /app/data
+RUN mkdir -p /app/code_interpreter
+
+# Give write permission to the directory
+RUN chmod -R 777 /app/uploads/temp
+RUN chmod -R 777 /app/client/public/images
+RUN chmod -R 777 /app/api/logs/
+RUN chmod -R 777 /app/data
+RUN chmod -R 777 /app/code_interpreter
+
+# RUN cd /app/packages/mcp/src/ && rm -rf  manager.ts 
+
+# Copy Custom Endpoints Config
+# RUN curl -o /app/librechat.yaml https://raw.githubusercontent.com/LibreChat-AI/librechat-config-yaml/main/librechat-hf.yaml
+COPY librechat.yaml /app/librechat.yaml 
+COPY tests.py /app/tests.py
+COPY streamlit_app.py /app/streamlit_app.py
+COPY gradio_file.py /app/gradio_file.py
+
+# Install dependencies
+RUN cd /app/api && npm install 
+USER root
+# COPY manager.ts /app/packages/mcp/src/manager.ts
+
+# Install Python and pip
+ENV PYTHONUNBUFFERED=1
+RUN apk add --update --no-cache python3-dev  git py3-pip gcc libc-dev libc6-compat build-base mpc1-dev && ln -sf python3 /usr/bin/python
+# RUN apk --update --no-cache add python3~3.10    --repository=http://dl-cdn.alpinelinux.org/alpine/edge/main 
+# RUN apk add --update --no-cache  git  gcc libc-dev libc6-compat build-base mpc1-dev && ln -sf python3 /usr/bin/python
+
+# RUN python3 -m ensurepip    
+
+RUN pip3 install --no-cache --upgrade  --break-system-packages pip setuptools mcp mcp-simple-pubmed mcp-simple-arxiv e2b-code-interpreter==1.0.4b litellm gradio XlsxWriter openpyxl google-genai  requests-futures
+# RUN cd /app/packages && git clone  --branch patch-1 https://github.com/vaibhavard/actors-mcp-server 
+# RUN cd /app/packages/actors-mcp-server/ && npm install  && npm run build  && npm link
+# RUN git clone https://github.com/e2b-dev/mcp-server && cd mcp-server/packages/js/ && npm install && npm run build && npm link
+#  to run on container start
+RUN git clone https://github.com/AIGENHACKER/mcp-hfspace && cd mcp-hfspace && npm install && npm run build && npm link
+RUN git clone https://github.com/exa-labs/exa-mcp-server  && cd exa-mcp-server  && npm install --save axios dotenv && npm run build && npm link 
+CMD ["npm", "run", "backend"]

gradio_file.py

@@ -0,0 +1,138 @@
+
+import gradio as gr
+import os
+import shutil
+
+# --- Configuration ---
+INITIAL_PATH = os.getcwd()  # Start in the current working directory
+ALLOWED_EXTENSIONS_UPLOAD = None  # Allow all file types for upload initially, or set a list like ['.txt', '.pdf']
+ALLOWED_EXTENSIONS_DOWNLOAD = None # Allow all for download, or restrict if needed
+
+# --- Helper Functions ---
+
+def list_files_and_folders(path):
+    """Lists files and folders in a given directory."""
+    try:
+        items = os.listdir(path)
+        files = []
+        folders = []
+        for item in items:
+            item_path = os.path.join(path, item)
+            if os.path.isfile(item_path):
+                files.append(item)
+            elif os.path.isdir(item_path):
+                folders.append(item)
+        return folders, files, path, None  # Return folders, files, current path, and no error
+    except Exception as e:
+        return [], [], path, str(e) # Return empty lists and error message
+
+def change_directory(path, current_path, direction):
+    """Changes the current directory (up or into a folder)."""
+    new_path = current_path
+    if direction == "up":
+        new_path = os.path.dirname(current_path)
+    elif direction == "enter":
+        new_path = os.path.join(current_path, path) # Path here is the selected folder
+    elif direction == "refresh":
+        new_path = current_path # Just refresh current
+
+    if not os.path.exists(new_path) or not os.path.isdir(new_path):
+        return [], [], current_path, "Invalid directory path."
+
+    return list_files_and_folders(new_path)
+
+def upload_file(files, current_path):
+    """Uploads files to the current directory."""
+    if not files:
+        return [], [], current_path, "No files uploaded."
+
+    uploaded_filenames = []
+    for file in files:
+        try:
+            filename = os.path.basename(file.name) # Get original filename
+            destination_path = os.path.join(current_path, filename)
+
+            if ALLOWED_EXTENSIONS_UPLOAD: # Check allowed extensions if specified
+                file_extension = os.path.splitext(filename)[1].lower()
+                if file_extension not in ALLOWED_EXTENSIONS_UPLOAD:
+                    return [], [], current_path, f"File type '{file_extension}' not allowed for upload."
+
+            shutil.copyfile(file.name, destination_path) # Copy uploaded file
+            uploaded_filenames.append(filename)
+        except Exception as e:
+            return [], [], current_path, f"Error uploading file '{filename}': {str(e)}"
+
+    # Refresh file list after upload
+    return list_files_and_folders(current_path)
+
+
+def download_file(file_path, current_path):
+    """Returns the file path for download."""
+    full_file_path = os.path.join(current_path, file_path) # Construct full path
+
+    if not os.path.isfile(full_file_path):
+        return None, "File not found for download."
+
+    if ALLOWED_EXTENSIONS_DOWNLOAD: # Check allowed extensions if specified
+        file_extension = os.path.splitext(full_file_path)[1].lower()
+        if file_extension not in ALLOWED_EXTENSIONS_DOWNLOAD:
+            return None, f"File type '{file_extension}' not allowed for download."
+
+    return full_file_path, None
+
+
+# --- Gradio Interface ---
+
+with gr.Blocks() as demo:
+    current_directory = gr.State(INITIAL_PATH)
+
+    with gr.Row():
+        current_path_display = gr.Textbox(value=INITIAL_PATH, label="Current Path", interactive=False, scale=4)
+        refresh_button = gr.Button("Refresh", scale=1)
+        up_button = gr.Button("Up", scale=1)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            folder_output = gr.List([], headers=["Folders"], label="Folders",  elem_id="folder-list", interactive=False) # Removed type="value"
+            file_output = gr.List([], headers=["Files"], label="Files", elem_id="file-list", interactive=False) # Removed type="value"
+        with gr.Column(scale=2):
+            upload_component = gr.File(label="Upload Files", file_count="multiple") # Allows multiple file uploads
+            download_button = gr.File(label="Download Selected File")
+            error_output = gr.Markdown(label="Status")
+
+
+    # --- Functionality ---
+
+    def update_file_list(current_path):
+        folders, files, updated_path, error = list_files_and_folders(current_path)
+        return folders, files, updated_path, updated_path, error
+
+    def on_folder_select(folder_name, current_path_state):
+        return change_directory(folder_name, folder_output.value, "enter") # Corrected: use folder_output.value not folder_name directly
+
+    def on_up_button_click(current_path_state):
+        return change_directory("", current_path_state, "up") # Path is empty for "up"
+
+    def on_refresh_button_click(current_path_state):
+        return change_directory("", current_path_state, "refresh") # Path is empty for "refresh"
+
+    def on_file_upload(uploaded_files, current_path_state):
+        return upload_file(uploaded_files, current_path_state)
+
+    def on_file_select_for_download(file_name, current_path_state):
+        return download_file(file_name, current_path_state)
+
+
+    # --- Event Handlers ---
+
+    demo.load(update_file_list, inputs=current_directory, outputs=[folder_output, file_output, current_directory, current_path_display, error_output])
+
+    folder_output.select(on_folder_select, [folder_output, current_directory], [folder_output, file_output, current_directory, current_path_display, error_output])
+    up_button.click(on_up_button_click, inputs=current_directory, outputs=[folder_output, file_output, current_directory, current_path_display, error_output])
+    refresh_button.click(on_refresh_button_click, inputs=current_directory, outputs=[folder_output, file_output, current_directory, current_path_display, error_output])
+    upload_component.upload(on_file_upload, [upload_component, current_directory], [folder_output, file_output, current_directory, current_path_display, error_output] ) # clear_value=True to reset upload after submission
+    file_output.select(on_file_select_for_download, [file_output, current_directory], [download_button, error_output])
+
+
+if __name__ == "__main__":
+    demo.launch(share=True,server_port=1337)

librechat.yaml

@@ -0,0 +1,449 @@
+# For more information, see the Configuration Guide:
+# https://www.librechat.ai/docs/configuration/librechat_yaml
+
+# Configuration version (required)
+version: 1.2.1
+
+# Cache settings: Set to true to enable caching
+cache: true
+
+# Custom interface configuration
+interface:
+  # Privacy policy settings
+  privacyPolicy:
+    externalUrl: 'https://librechat.ai/privacy-policy'
+    openNewTab: true
+
+  # Terms of service
+  termsOfService:
+    externalUrl: 'https://librechat.ai/tos'
+    openNewTab: true
+    modalAcceptance: true
+    modalTitle: "Terms of Service for LibreChat"
+    modalContent: |
+      # Terms and Conditions for LibreChat
+
+      Please do not use chatgpt , since librechat is better 😀
+
+      Regards , Vaibhav 
+
+      
+
+  endpointsMenu: true
+  modelSelect: true
+  parameters: true
+  sidePanel: true
+  presets: true
+  prompts: true
+  bookmarks: true
+  multiConvo: true
+  agents: true
+
+# Example Registration Object Structure (optional)
+registration:
+  socialLogins: ['github', 'google', 'discord', 'openid', 'facebook']
+  # allowedDomains:
+  # - "gmail.com"
+
+# speech:
+#   tts:
+#     openai:
+#       url: ''
+#       apiKey: '${TTS_API_KEY}'
+#       model: ''
+#       voices: ['']
+
+#  
+#   stt:
+#     openai:
+#       url: ''
+#       apiKey: '${STT_API_KEY}'
+#       model: ''
+
+# rateLimits:
+#   fileUploads:
+#     ipMax: 100
+#     ipWindowInMinutes: 60  # Rate limit window for file uploads per IP
+#     userMax: 50
+#     userWindowInMinutes: 60  # Rate limit window for file uploads per user
+#   conversationsImport:
+#     ipMax: 100
+#     ipWindowInMinutes: 60  # Rate limit window for conversation imports per IP
+#     userMax: 50
+#     userWindowInMinutes: 60  # Rate limit window for conversation imports per user
+
+# Example Actions Object Structure
+actions:
+  allowedDomains:
+    - "swapi.dev"
+    - "librechat.ai"
+    - "google.com"
+    - "https://api.e2b.dev"
+    - "api.e2b.dev"
+# Example MCP Servers Object Structure
+mcpServers:
+  # everything:
+  #   type: sse # type can optionally be omitted
+  #   url: https://787d-182-69-182-121.ngrok-free.app/
+
+
+  # memory:
+  #  type: stdio
+  #  command: npx
+  #  args:
+  #    - -y
+  #    - "@modelcontextprotocol/server-memory"
+  #  timeout: 60000000
+
+
+  # apify:
+  #   type: stdio
+  #   command: npx
+  #   args:
+  #     - -y
+  #     - "@apify/actors-mcp-server"
+  #     - --actors
+  #     - apify/screenshot-url,apify/website-content-crawler,apify/puppeteer-scraper,apify/rag-web-browser,jancurn/screenshot-taker,apify/cheerio-scraper,apify/playwright-scraper,apify/ai-web-agent,marco.gullo/page-printer,dz_omar/example-website-screenshot-crawler,apify/legacy-phantomjs-crawler,lukaskrivka/article-extractor-smart
+  #   timeout: 60000000
+  #   env:
+  #     APIFY_TOKEN: "apify_api_M3vftXQILokc2NDlhsc3twMBa5e7Be282swR"
+      # PATH: "/usr/local/bin:/usr/bin:/bin"
+      # NODE_PATH: "/usr/local/lib/node_modules" 
+
+  hfspace:
+    type: stdio
+    command: npx
+    args:
+      - -y
+      - "@llmindset/mcp-hfspace"
+      - --HF_TOKEN=${HF_TOKEN}
+      - --work-dir=/app/uploads/temp/
+      - Qwen/Qwen2.5-Max-Demo
+      - evalstate/FLUX.1-schnell
+    timeout: 60000000
+  #   env:
+  #    E2B_API_KEY: "e2b_6eb042e8d60248f71b0aadcc05f29a7dd353b3e2"
+  #    PATH: "/usr/local/bin:/usr/bin:/bin"
+  #    NODE_PATH: "/usr/local/lib/node_modules" 
+  exa:
+    type: stdio
+    command: npx
+    args:
+      - -y
+      - "/app/exa-mcp-server/build/index.js"
+      # - --HF_TOKEN=${HF_TOKEN}
+    timeout: 60000000
+    env:
+     EXA_API_KEY: "e4399980-1016-44ab-8789-1ef7f967a281"
+     PATH: "/usr/local/bin:/usr/bin:/bin"
+     NODE_PATH: "/usr/local/lib/node_modules" 
+  arxiv:
+    type: stdio
+    command: python
+    args:
+      - -m
+      - mcp_simple_arxiv
+    timeout: 60000000
+  pubmed:
+    type: stdio
+    command: python
+    args:
+      - -m
+      - mcp_simple_pubmed
+    env:
+      PUBMED_EMAIL: "[email protected]"
+      PUBMED_API_KEY : "77ea72d89b98d279c1848389cd027a51c408"
+      PATH: "/usr/local/bin:/usr/bin:/bin"
+      NODE_PATH: "/usr/local/lib/node_modules" 
+  memory:
+   type: stdio
+   command: npx
+   args:
+     - -y
+     - "@modelcontextprotocol/server-memory"
+   timeout: 60000000
+  filesystem:
+    # type: stdio
+    command: npx
+    args:
+      - -y
+      - "@modelcontextprotocol/server-filesystem"
+      - /app/
+  codesandbox:
+    type: stdio
+    command: python
+    args:
+      - tests.py
+    timeout: 60000000
+# Definition of custom endpoints
+endpoints:
+  agents:
+    recursionLimit: 50
+    disableBuilder: false
+    capabilities:
+      # - "execute_code"
+      - "file_search"
+      - "actions"
+      - "tools"
+
+
+  custom:
+    # together.ai
+    # https://api.together.ai/settings/api-keys
+    # Model list: https://docs.together.ai/docs/inference-models
+    - name: "together.ai"
+      apiKey: '${MISTRAL_API_KEY}'
+      baseURL: "https://api.together.xyz"
+      models:
+        default: [
+          "Gryphe/MythoMax-L2-13b",
+          "Gryphe/MythoMax-L2-13b-Lite",
+          "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+          "Qwen/QwQ-32B-Preview",
+          "Qwen/Qwen2-72B-Instruct",
+          "Qwen/Qwen2-VL-72B-Instruct",
+          "Qwen/Qwen2.5-72B-Instruct-Turbo",
+          "Qwen/Qwen2.5-7B-Instruct-Turbo",
+          "Qwen/Qwen2.5-Coder-32B-Instruct",
+          "databricks/dbrx-instruct",
+          "deepseek-ai/DeepSeek-R1",
+          "deepseek-ai/DeepSeek-V3",
+          "deepseek-ai/deepseek-llm-67b-chat",
+          "dev-vfs/Qwen2-VL-72B-Instruct",
+          "devuser/test-lora-model-creation-1",
+          "devuser/test-lora-model-creation-10",
+          "devuser/test-lora-model-creation-2",
+          "devuser/test-lora-model-creation-3",
+          "devuser/test-lora-model-creation-4",
+          "devuser/test-lora-model-creation-5",
+          "devuser/test-lora-model-creation-6",
+          "devuser/test-lora-model-creation-7",
+          "devuser/test-lora-model-creation-8",
+          "devuser/test-lora-model-creation-9",
+          "google/gemma-2-27b-it",
+          "google/gemma-2-9b-it",
+          "google/gemma-2b-it",
+          "jd/test-lora-model-creation-2",
+          "jd/test-min-lora-model-creation-2",
+          "justindriemeyer_tai/test-lora-model-creation-3",
+          "justindriemeyer_tai/test-lora-model-creation-4",
+          "justindriemeyer_tai/test-lora-model-creation-5",
+          "justindriemeyer_tai/test-lora-model-creation-6",
+          "justindriemeyer_tai/test-lora-model-creation-7",
+          "llava-hf/llava-v1.6-mistral-7b-hf",
+          "meta-llama/Llama-2-13b-chat-hf",
+          "meta-llama/Llama-2-7b-chat-hf",
+          "meta-llama/Llama-3-70b-chat-hf",
+          "meta-llama/Llama-3-8b-chat-hf",
+          "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+          "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+          "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
+          "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+          "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+          "meta-llama/Llama-Vision-Free",
+          "meta-llama/Meta-Llama-3-70B-Instruct-Lite",
+          "meta-llama/Meta-Llama-3-70B-Instruct-Turbo",
+          "meta-llama/Meta-Llama-3-8B-Instruct-Lite",
+          "meta-llama/Meta-Llama-3-8B-Instruct-Turbo",
+          "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+          "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+          "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo-128K",
+          "microsoft/WizardLM-2-8x22B",
+          "mistralai/Mistral-7B-Instruct-v0.1",
+          "mistralai/Mistral-7B-Instruct-v0.2",
+          "mistralai/Mistral-7B-Instruct-v0.3",
+          "mistralai/Mixtral-8x22B-Instruct-v0.1",
+          "mistralai/Mixtral-8x7B-Instruct-v0.1",
+          "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
+          "salesforce/xgen-9b-instruct",
+          "scb10x/llama-3-typhoon-v1.5-8b-instruct",
+          "scb10x/scb10x-llama3-typhoon-v1-5-8b-instruct",
+          "scb10x/scb10x-llama3-typhoon-v1-5x-4f316",
+          "togethercomputer/Llama-3-8b-chat-hf-int4",
+          "togethercomputer/Llama-3-8b-chat-hf-int8",
+          "upstage/SOLAR-10.7B-Instruct-v1.0",
+          "vfs/Qwen2-VL-72B-Instruct"
+          ]
+        fetch: false
+      titleConvo: true
+      titleModel: "openchat/openchat-3.5-1210"
+      summarize: false
+      summaryModel: "openchat/openchat-3.5-1210"
+      forcePrompt: false
+      modelDisplayLabel: "together.ai"
+    - name: "OpenRouter"
+      # For `apiKey` and `baseURL`, you can use environment variables that you define.
+      # recommended environment variables:
+      apiKey: "${OPENROUTER_KEY}" # NOT OPENROUTER_API_KEY
+      baseURL: "https://openrouter.ai/api/v1"
+      models:
+        default: ["deepseek/deepseek-chat","deepseek/deepseek-r1:free","google/gemini-2.0-flash-thinking-exp:free","google/gemini-2.0-flash-exp:free","google/gemini-exp-1206:free"]
+        fetch: true
+      titleConvo: true
+      titleModel: "google/gemini-2.0-flash-exp:free"
+      # Recommended: Drop the stop parameter from the request as Openrouter models use a variety of stop tokens.
+      dropParams: ["stop"]
+      modelDisplayLabel: "OpenRouter"
+    # Groq Example
+    - name: 'groq'
+      apiKey: '${GROQ_API_KEY}'
+      baseURL: 'https://api.groq.com/openai/v1/'
+      models:
+        default:
+          [
+            'deepseek-r1-distill-qwen-32b',
+            'deepseek-r1-distill-llama-70b',
+            'llama-3.3-70b-versatile',
+            'mixtral-8x7b-32768',
+            'qwen-qwq-32b',
+          ]
+        fetch: false
+      titleConvo: true
+      titleModel: 'mixtral-8x7b-32768'
+      modelDisplayLabel: 'groq'
+    - name: 'Tiny' # Unique name for the endpoint
+      # For `apiKey` and `baseURL`, you can use environment variables that you define.
+      # recommended environment variables:
+      apiKey: '77ea72d89b98d279c1848389cd027a51c408'
+      baseURL: 'https://962f-182-69-182-236.ngrok-free.app'
+
+      # Models configuration
+      models:
+        # List of default models to use. At least one value is required.
+        default: ['gemini-2.0-flash-thinking-exp-01-21' ,'deepseek.r1','deepseek-reasoner','deepseek-chat','gemini-2.0-pro-exp-02-05','deepseek-r1-distill-llama-70b', 'qwen-qwq-32b','QwQ-32B','llama-3.3-70b-versatile','DeepSeek-V3','DeepSeekV3-togetherAI','DeepSeek-R1','DeepSeekR1-togetherAI','gpt-4o','DeepSeek-R1-dev','DeepSeek-V3-dev']
+        # Fetch option: Set to true to fetch models from API.
+        # fetch: true # Defaults to false.
+
+      # Optional configurations
+
+      # Title Conversation setting
+      titleConvo: true # Set to true to enable title conversation
+
+      modelDisplayLabel: 'AI' # Default is "AI" when not set.
+    - name: 'Tiny-DEV' # Unique name for the endpoint
+      # For `apiKey` and `baseURL`, you can use environment variables that you define.
+      # recommended environment variables:
+      apiKey: '77ea72d89b98d279c1848389cd027a51c408'
+      baseURL: 'https://akiko19191-backend.hf.space/'
+
+      # Models configuration
+      models:
+        # List of default models to use. At least one value is required.
+        default: ['gemini-2.0-flash-thinking-exp-01-21' ,'deepseek.r1','deepseek-reasoner','deepseek-chat','gemini-2.0-pro-exp-02-05','deepseek-r1-distill-llama-70b', 'qwen-qwq-32b','QwQ-32B','llama-3.3-70b-versatile','DeepSeek-V3','DeepSeekV3-togetherAI','DeepSeek-R1','DeepSeekR1-togetherAI','gpt-4o','DeepSeek-R1-dev','DeepSeek-V3-dev']
+        # Fetch option: Set to true to fetch models from API.
+        # fetch: false # Defaults to false.
+
+      # Optional configurations
+
+      # Title Conversation setting
+      titleConvo: true # Set to true to enable title conversation
+
+      modelDisplayLabel: 'Tiny' # Default is "AI" when not set.
+  #   # Mistral AI Example
+  #   - name: 'Mistral' # Unique name for the endpoint
+  #     # For `apiKey` and `baseURL`, you can use environment variables that you define.
+  #     # recommended environment variables:
+  #     apiKey: '${MISTRAL_API_KEY}'
+  #     baseURL: 'https://api.mistral.ai/v1'
+
+  #     # Models configuration
+  #     models:
+  #       # List of default models to use. At least one value is required.
+  #       default: ['mistral-tiny', 'mistral-small', 'mistral-medium']
+  #       # Fetch option: Set to true to fetch models from API.
+  #       fetch: true # Defaults to false.
+
+  #     # Optional configurations
+
+  #     # Title Conversation setting
+  #     titleConvo: true # Set to true to enable title conversation
+
+  #     # Title Method: Choose between "completion" or "functions".
+  #     # titleMethod: "completion"  # Defaults to "completion" if omitted.
+
+  #     # Title Model: Specify the model to use for titles.
+  #     titleModel: 'mistral-tiny' # Defaults to "gpt-3.5-turbo" if omitted.
+
+  #     # Summarize setting: Set to true to enable summarization.
+  #     # summarize: false
+
+  #     # Summary Model: Specify the model to use if summarization is enabled.
+  #     # summaryModel: "mistral-tiny"  # Defaults to "gpt-3.5-turbo" if omitted.
+
+  #     # Force Prompt setting: If true, sends a `prompt` parameter instead of `messages`.
+  #     # forcePrompt: false
+
+  #     # The label displayed for the AI model in messages.
+  #     modelDisplayLabel: 'Mistral' # Default is "AI" when not set.
+
+  #     # Add additional parameters to the request. Default params will be overwritten.
+  #     # addParams:
+  #     # safe_prompt: true # This field is specific to Mistral AI: https://docs.mistral.ai/api/
+
+  #     # Drop Default params parameters from the request. See default params in guide linked below.
+  #     # NOTE: For Mistral, it is necessary to drop the following parameters or you will encounter a 422 Error:
+  #     dropParams: ['stop', 'user', 'frequency_penalty', 'presence_penalty']
+
+  #   # OpenRouter Example
+  #   - name: 'OpenRouter'
+  #     # For `apiKey` and `baseURL`, you can use environment variables that you define.
+  #     # recommended environment variables:
+  #     # Known issue: you should not use `OPENROUTER_API_KEY` as it will then override the `openAI` endpoint to use OpenRouter as well.
+  #     apiKey: '${OPENROUTER_KEY}'
+  #     baseURL: 'https://openrouter.ai/api/v1'
+  #     models:
+  #       default: ['meta-llama/llama-3-70b-instruct']
+  #       fetch: true
+  #     titleConvo: true
+  #     titleModel: 'meta-llama/llama-3-70b-instruct'
+  #     # Recommended: Drop the stop parameter from the request as Openrouter models use a variety of stop tokens.
+  #     dropParams: ['stop']
+  #     modelDisplayLabel: 'OpenRouter'
+    # together.ai
+    # https://api.together.ai/settings/api-keys
+    # Model list: https://docs.together.ai/docs/inference-models
+  #   # Portkey AI Example
+  #   - name: "Portkey"
+  #     apiKey: "dummy"  
+  #     baseURL: 'https://api.portkey.ai/v1'
+  #     headers:
+  #         x-portkey-api-key: '${PORTKEY_API_KEY}'
+  #         x-portkey-virtual-key: '${PORTKEY_OPENAI_VIRTUAL_KEY}'
+  #     models:
+  #         default: ['gpt-4o-mini', 'gpt-4o', 'chatgpt-4o-latest']
+  #         fetch: true
+  #     titleConvo: true
+  #     titleModel: 'current_model'
+  #     summarize: false
+  #     summaryModel: 'current_model'
+  #     forcePrompt: false
+  #     modelDisplayLabel: 'Portkey'
+  #     iconURL: https://images.crunchbase.com/image/upload/c_pad,f_auto,q_auto:eco,dpr_1/rjqy7ghvjoiu4cd1xjbf
+fileConfig:
+  endpoints:
+    agents:
+      fileLimit: 5
+      fileSizeLimit: 100  # Maximum size for an individual file in MB
+      totalSizeLimit: 500  # Maximum total size for all files in a single request in MB
+      supportedMimeTypes:
+        - "image/.*"
+        - "application/pdf"
+        - "video/.*"
+        - "application/vnd.ms-excel"
+        - "audio/mp3"
+        - "audio/mpeg"
+        - "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        - "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        - "application/msword"
+    # openAI:
+#       disabled: true  # Disables file uploading to the OpenAI endpoint
+#     default:
+#       totalSizeLimit: 20
+#     YourCustomEndpointName:
+#       fileLimit: 2
+#       fileSizeLimit: 5
+#   serverFileSizeLimit: 100  # Global server file size limit in MB
+#   avatarSizeLimit: 2  # Limit for user avatar image size in MB
+# See the Custom Configuration Guide for more information on Assistants Config:
+# https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/assistants_endpoint

manager.ts

@@ -0,0 +1,238 @@
+import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import type { JsonSchemaType } from 'librechat-data-provider';
+import type { Logger } from 'winston';
+import type * as t from './types/mcp';
+import { formatToolContent } from './parsers';
+import { MCPConnection } from './connection';
+import { CONSTANTS } from './enum';
+
+export class MCPManager {
+  private static instance: MCPManager | null = null;
+  private connections: Map<string, MCPConnection> = new Map();
+  private logger: Logger;
+
+  private static getDefaultLogger(): Logger {
+    return {
+      error: console.error,
+      warn: console.warn,
+      info: console.info,
+      debug: console.debug,
+    } as Logger;
+  }
+
+  private constructor(logger?: Logger) {
+    this.logger = logger || MCPManager.getDefaultLogger();
+  }
+
+  public static getInstance(logger?: Logger): MCPManager {
+    if (!MCPManager.instance) {
+      MCPManager.instance = new MCPManager(logger);
+    }
+    return MCPManager.instance;
+  }
+
+  public async initializeMCP(mcpServers: t.MCPServers): Promise<void> {
+    this.logger.info('[MCP] Initializing servers');
+
+    const entries = Object.entries(mcpServers);
+    const initializedServers = new Set();
+    const connectionResults = await Promise.allSettled(
+      entries.map(async ([serverName, config], i) => {
+        const connection = new MCPConnection(serverName, config, this.logger);
+
+        connection.on('connectionChange', (state) => {
+          this.logger.info(`[MCP][${serverName}] Connection state: ${state}`);
+        });
+
+        try {
+          const connectionTimeout = new Promise<void>((_, reject) =>
+            setTimeout(() => reject(new Error('Connection timeout')), 1800000),
+          );
+
+          const connectionAttempt = this.initializeServer(connection, serverName);
+          await Promise.race([connectionAttempt, connectionTimeout]);
+
+          if (connection.isConnected()) {
+            initializedServers.add(i);
+            this.connections.set(serverName, connection);
+
+            const serverCapabilities = connection.client.getServerCapabilities();
+            this.logger.info(
+              `[MCP][${serverName}] Capabilities: ${JSON.stringify(serverCapabilities)}`,
+            );
+
+            if (serverCapabilities?.tools) {
+              const tools = await connection.client.listTools();
+              if (tools.tools.length) {
+                this.logger.info(
+                  `[MCP][${serverName}] Available tools: ${tools.tools
+                    .map((tool) => tool.name)
+                    .join(', ')}`,
+                );
+              }
+            }
+          }
+        } catch (error) {
+          this.logger.error(`[MCP][${serverName}] Initialization failed`, error);
+          throw error;
+        }
+      }),
+    );
+
+    const failedConnections = connectionResults.filter(
+      (result): result is PromiseRejectedResult => result.status === 'rejected',
+    );
+
+    this.logger.info(`[MCP] Initialized ${initializedServers.size}/${entries.length} server(s)`);
+
+    if (failedConnections.length > 0) {
+      this.logger.warn(
+        `[MCP] ${failedConnections.length}/${entries.length} server(s) failed to initialize`,
+      );
+    }
+
+    entries.forEach(([serverName], index) => {
+      if (initializedServers.has(index)) {
+        this.logger.info(`[MCP][${serverName}] ✓ Initialized`);
+      } else {
+        this.logger.info(`[MCP][${serverName}] ✗ Failed`);
+      }
+    });
+
+    if (initializedServers.size === entries.length) {
+      this.logger.info('[MCP] All servers initialized successfully');
+    } else if (initializedServers.size === 0) {
+      this.logger.error('[MCP] No servers initialized');
+    }
+  }
+
+  private async initializeServer(connection: MCPConnection, serverName: string): Promise<void> {
+    const maxAttempts = 3;
+    let attempts = 0;
+
+    while (attempts < maxAttempts) {
+      try {
+        await connection.connect();
+
+        if (connection.isConnected()) {
+          return;
+        }
+      } catch (error) {
+        attempts++;
+
+        if (attempts === maxAttempts) {
+          this.logger.error(`[MCP][${serverName}] Failed after ${maxAttempts} attempts`);
+          throw error;
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, 2000 * attempts));
+      }
+    }
+  }
+
+  public getConnection(serverName: string): MCPConnection | undefined {
+    return this.connections.get(serverName);
+  }
+
+  public getAllConnections(): Map<string, MCPConnection> {
+    return this.connections;
+  }
+
+  public async mapAvailableTools(availableTools: t.LCAvailableTools): Promise<void> {
+    for (const [serverName, connection] of this.connections.entries()) {
+      try {
+        if (connection.isConnected() !== true) {
+          this.logger.warn(`Connection ${serverName} is not connected. Skipping tool fetch.`);
+          continue;
+        }
+
+        const tools = await connection.fetchTools();
+        for (const tool of tools) {
+          const name = `${tool.name}${CONSTANTS.mcp_delimiter}${serverName}`;
+          availableTools[name] = {
+            type: 'function',
+            ['function']: {
+              name,
+              description: tool.description,
+              parameters: tool.inputSchema as JsonSchemaType,
+            },
+          };
+        }
+      } catch (error) {
+        this.logger.warn(`[MCP][${serverName}] Not connected, skipping tool fetch`);
+      }
+    }
+  }
+
+  public async loadManifestTools(manifestTools: t.LCToolManifest): Promise<void> {
+    for (const [serverName, connection] of this.connections.entries()) {
+      try {
+        if (connection.isConnected() !== true) {
+          this.logger.warn(`Connection ${serverName} is not connected. Skipping tool fetch.`);
+          continue;
+        }
+
+        const tools = await connection.fetchTools();
+        for (const tool of tools) {
+          const pluginKey = `${tool.name}${CONSTANTS.mcp_delimiter}${serverName}`;
+          manifestTools.push({
+            name: tool.name,
+            pluginKey,
+            description: tool.description ?? '',
+            icon: connection.iconPath,
+          });
+        }
+      } catch (error) {
+        this.logger.error(`[MCP][${serverName}] Error fetching tools`, error);
+      }
+    }
+  }
+
+  async callTool(
+    serverName: string,
+    toolName: string,
+    provider: t.Provider,
+    toolArguments?: Record<string, unknown>,
+  ): Promise<t.FormattedToolResponse> {
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new Error(
+        `No connection found for server: ${serverName}. Please make sure to use MCP servers available under 'Connected MCP Servers'.`,
+      );
+    }
+    const result = await connection.client.request(
+      {
+        method: 'tools/call',
+        params: {
+          name: toolName,
+          arguments: toolArguments,
+        },
+      },
+      CallToolResultSchema,
+    );
+    return formatToolContent(result, provider);
+  }
+
+  public async disconnectServer(serverName: string): Promise<void> {
+    const connection = this.connections.get(serverName);
+    if (connection) {
+      await connection.disconnect();
+      this.connections.delete(serverName);
+    }
+  }
+
+  public async disconnectAll(): Promise<void> {
+    const disconnectPromises = Array.from(this.connections.values()).map((connection) =>
+      connection.disconnect(),
+    );
+    await Promise.all(disconnectPromises);
+    this.connections.clear();
+  }
+
+  public static async destroyInstance(): Promise<void> {
+    if (MCPManager.instance) {
+      await MCPManager.instance.disconnectAll();
+      MCPManager.instance = null;
+    }
+  }
+}

streamlit_app.py

@@ -0,0 +1,132 @@
+# import streamlit as st
+# import os
+# import shutil
+
+# def main():
+#     st.title("File Explorer")
+
+#     # File browsing
+#     st.header("Browse Files")
+#     current_dir = st.text_input("Current Directory", value=os.getcwd())
+
+#     try:
+#         files = os.listdir(current_dir)
+#         selected_file = st.selectbox("Select a file/folder", files)
+#         full_path = os.path.join(current_dir, selected_file)
+
+#         if selected_file:
+#              if os.path.isfile(full_path):
+#                 st.write(f"You selected file: {selected_file}")
+
+#                 # Download
+#                 with open(full_path, "rb") as f:
+#                   st.download_button("Download", f, file_name=selected_file)
+
+#                 # Read
+#                 if selected_file.endswith((".txt",".py",".md",".csv")):
+#                   try:
+#                     with open(full_path,"r") as f_read:
+#                       content = f_read.read()
+#                       st.text_area("File content", content, height=300)
+#                   except UnicodeDecodeError:
+#                       st.write("Cannot display binary file content.")
+#              elif os.path.isdir(full_path):
+#                 st.write(f"You selected directory: {selected_file}")
+
+
+#     except FileNotFoundError:
+#         st.error("Invalid directory path.")
+#     except PermissionError:
+#         st.error("Permission denied to access this directory.")
+#     except OSError as e:
+#         st.error(f"OS error: {e}")
+
+
+#     # File Uploading
+#     st.header("Upload Files")
+#     uploaded_files = st.file_uploader("Choose files to upload", accept_multiple_files=True)
+#     upload_dir = st.text_input("Upload Directory", value=os.getcwd())
+#     if uploaded_files:
+#       for uploaded_file in uploaded_files:
+#           try:
+#               with open(os.path.join(upload_dir, uploaded_file.name), "wb") as f:
+#                   f.write(uploaded_file.getbuffer())
+#               st.success(f"Saved File: {uploaded_file.name} to {upload_dir}")
+#           except Exception as e:
+#               st.error(f"Error saving file: {e}")
+
+
+# if __name__ == "__main__":
+#     main()
+
+from flask import Flask, url_for, redirect
+from flask import request as req
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)
+from werkzeug.utils import secure_filename
+import os
+from PIL import Image
+app.config['UPLOAD_FOLDER'] = "static"
+from pyngrok import ngrok
+
+# Open a HTTP tunnel on the default port 80
+# <NgrokTunnel: "https://<public_sub>.ngrok.io" -> "http://localhost:80">
+http_tunnel = ngrok.connect("1337", "http")
+print(http_tunnel)
+@app.route('/upload', methods=['GET','POST'])
+def index():
+ 
+    # If a post method then handle file upload
+    if req.method == 'POST':
+ 
+        if 'file' not in req.files:
+            return redirect('/')
+ 
+        file = req.files['file']
+ 
+ 
+        if file :
+            filename = secure_filename(file.filename)
+            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+            if ("camera" in file.filename or "capture" in file.filename or "IMG" in file.filename or "Screenshot"  in file.filename) :
+                img=Image.open(f"static/{filename}")
+                img.thumbnail((512, 512),Image.Resampling.LANCZOS)
+
+                img.save(f"static/{filename}")
+
+            return filename
+ 
+ 
+    # Get Files in the directory and create list items to be displayed to the user
+    file_list = ''
+    for f in os.listdir(app.config['UPLOAD_FOLDER']):
+        # Create link html
+        link = url_for("static", filename=f) 
+        file_list = file_list + '<li><a href="%s">%s</a></li>' % (link, f)
+ 
+    # Format return HTML - allow file upload and list all available files
+    return_html = '''
+    <!doctype html>
+    <title>Upload File</title>
+    <h1>Upload File</h1>
+    <form method=post enctype=multipart/form-data>
+            <input type=file name=file><br>
+            <input type=submit value=Upload>
+    </form>
+    <hr>
+    <h1>Files</h1>
+    <ol>%s</ol>
+    ''' % file_list
+ 
+    return return_html
+
+if __name__ == '__main__':
+    config = {
+        'host': 'localhost',
+        'port': 1337,
+        'debug': True,
+    }
+
+    app.run(**config)

tests.py

@@ -0,0 +1,391 @@
+from mcp.server.fastmcp import FastMCP
+import random 
+import time
+from litellm import completion
+import shlex
+from subprocess import Popen, PIPE
+from threading import Timer
+import os
+import glob
+import http.client
+import json
+import openpyxl
+import shutil
+from google import genai
+
+client = genai.Client(api_key="AIzaSyDtP05TyoIy9j0uPL7_wLEhgQEE75AZQSc")
+
+source_dir = "/app/uploads/temp"
+destination_dir = "/app/code_interpreter"
+files_list=[]
+downloaded_files=[]
+# os.environ.get('GROQ_API_KEY')
+os.environ["GROQ_API_KEY"] ="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"
+os.environ["GEMINI_API_KEY"] ="AIzaSyAQgAtQPpY0bQaCqCISGxeyF6tpDePx-Jg"
+os.environ["OPENROUTER_API_KEY"] = "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"
+mcp = FastMCP("code_sandbox")
+data={}
+result=""
+stdout=""
+stderr=""
+import requests
+import os
+from bs4 import BeautifulSoup  # For parsing HTML
+
+
+def download_all_files(base_url, files_endpoint, download_directory):
+    """Downloads all files listed on the server's /upload page."""
+    global downloaded_files
+
+    # Create the download directory if it doesn't exist
+    if not os.path.exists(download_directory):
+        os.makedirs(download_directory)
+
+    try:
+        # 1. Get the HTML of the /upload page
+        files_url = f"{base_url}{files_endpoint}"
+        response = requests.get(files_url)
+        response.raise_for_status()  # Check for HTTP errors
+
+        # 2. Parse the HTML using BeautifulSoup
+        soup = BeautifulSoup(response.content, "html.parser")
+
+        # 3. Find all the <a> (anchor) tags, which represent the links to the files
+        # This assumes the file links are inside <a> tags as shown in the server code
+        file_links = soup.find_all("a")
+
+        # 4. Iterate through the links and download the files
+        for link in file_links:
+            try:
+                file_url = link.get("href")  # Extract the href attribute (the URL)
+                if file_url:
+                    # Construct the full file URL if the href is relative
+                    if not file_url.startswith("http"):
+                        file_url = f"{base_url}{file_url}"  #  Relative URLs
+
+                    filename = os.path.basename(file_url) # Extract the filename from the URL
+                    file_path = os.path.join(download_directory, filename)
+                    if filename in downloaded_files:
+                        pass
+                    else:
+                        downloaded_files.append(filename)
+                        print(f"Downloading: {filename} from {file_url}")
+
+                        # Download the file
+                        file_response = requests.get(file_url, stream=True)  # Use stream=True for large files
+                        file_response.raise_for_status() # Check for HTTP errors
+
+                        with open(file_path, "wb") as file: # Open in binary write mode
+                            for chunk in file_response.iter_content(chunk_size=8192): # Iterate and write in chunks (good for large files)
+                                if chunk:  # filter out keep-alive new chunks
+                                    file.write(chunk)
+
+                        print(f"Downloaded: {filename} to {file_path}")
+
+            except requests.exceptions.RequestException as e:
+                print(f"Error downloading {link.get('href')}: {e}")
+            except OSError as e: #Handles potential issues with file permissions or disk space.
+                print(f"Error saving {filename}: {e}")
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error getting file list from server: {e}")
+    except Exception as e: # Catch all other potential errors
+        print(f"An unexpected error occurred: {e}")
+
+def transfer_files():
+    for item in os.listdir(source_dir):
+        item_path = os.path.join(source_dir, item)
+        if os.path.isdir(item_path): # Check if it's a directory
+            for filename in os.listdir(item_path):
+                source_file_path = os.path.join(item_path, filename)
+                destination_file_path = os.path.join(destination_dir, filename)
+                shutil.move(source_file_path, destination_file_path)
+
+def upload_file(file_path, upload_url):
+    """Uploads a file to the specified server endpoint."""
+
+    try:
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Prepare the file for upload
+        with open(file_path, "rb") as file:
+            files = {"file": (os.path.basename(file_path), file)}  #  Important: Provide filename
+
+            # Send the POST request
+            response = requests.post(upload_url, files=files)
+
+            # Check the response status code
+            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+
+            # Parse and print the response
+            if response.status_code == 200:
+                print(f"File uploaded successfully.  Filename returned by server: {response.text}")
+                return response.text # Return the filename returned by the server
+            else:
+                print(f"Upload failed. Status code: {response.status_code}, Response: {response.text}")
+                return None
+
+    except FileNotFoundError as e:
+        print(e)
+        return None  # or re-raise the exception if you want the program to halt
+    except requests.exceptions.RequestException as e:
+        print(f"Upload failed. Network error: {e}")
+        return None
+
+
+TOKEN = "5182224145:AAEjkSlPqV-Q3rH8A9X8HfCDYYEQ44v_qy0"
+chat_id = "5075390513"
+from requests_futures.sessions import FuturesSession
+session = FuturesSession()
+
+def run(cmd, timeout_sec):
+    global stdout 
+    global stderr
+    proc = Popen(shlex.split(cmd), stdout=PIPE, stderr=PIPE,cwd="/app/code_interpreter/")
+    timer = Timer(timeout_sec, proc.kill)
+    try:
+        timer.start()
+        stdout, stderr = proc.communicate()
+    finally:
+        timer.cancel()
+
+
+@mcp.tool()
+def analyse_audio(audiopath,query) -> dict:
+    """Ask another AI model about audios.The AI model can listen to the audio and give answers.Eg-query:Generate detailed minutes of meeting from the audio clip,audiopath='/app/code_interpreter/<audioname>'.Note:The audios are automatically present  in the /app/code_interpreter directory."""
+    download_all_files("https://opengpt-4ik5.onrender.com", "/upload", "/app/code_interpreter")
+    myfile = client.files.upload(file=audiopath)
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, myfile]
+    )
+    return {"Output":str(response.text)}
+
+@mcp.tool()
+def analyse_video(videopath,query) -> dict:
+    """Ask another AI model about videos.The AI model can see the videos and give answers.Eg-query:Create a very detailed transcript and summary of the video,videopath='/app/code_interpreter/<videoname>'Note:The videos are automatically present  in the /app/code_interpreter directory."""
+    download_all_files("https://opengpt-4ik5.onrender.com", "/upload", "/app/code_interpreter")
+    video_file = client.files.upload(file=videopath)
+
+    while video_file.state.name == "PROCESSING":
+        print('.', end='')
+        time.sleep(1)
+        video_file = client.files.get(name=video_file.name)
+
+    if video_file.state.name == "FAILED":
+        raise ValueError(video_file.state.name)
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, video_file]
+    )
+    return {"Output":str(response.text)}
+
+
+@mcp.tool()
+def analyse_images(imagepath,query) -> dict:
+    """Ask another AI model about images.The AI model can see the images and give answers.Eg-query:Who is the person in this image?,imagepath='/app/code_interpreter/<imagename>'.Note:The images are automatically present  in the /app/code_interpreter directory."""
+    download_all_files("https://opengpt-4ik5.onrender.com", "/upload", "/app/code_interpreter")
+    video_file = client.files.upload(file=imagepath)
+
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, video_file]
+    )
+    return {"Output":str(response.text)}
+
+@mcp.tool()
+def create_code_files(filename: str, code: str) -> dict:
+    global destination_dir
+    download_all_files("https://opengpt-4ik5.onrender.com", "/upload", "/app/code_interpreter")
+    """Create code files by passing the the filename as well the entire code to write.The file is created by default in the /app/code_interpreter directory.Note:All user uploaded files that you might need to work upon are stored in the /app/code_interpreter directory."""
+    transfer_files()
+    f = open(os.path.join(destination_dir, filename), "w")
+    f.write(code)
+    f.close()
+    return {"info":"task completed. The referenced code files were created successfully. "}
+
+
+
+@mcp.tool()
+def run_code_files(start_cmd:str) -> dict:
+    """(start_cmd:Example- sudo python /app/code_interpreter/app.py or bash /app/code_interpreter/app.py).The files must be inside the /app/code_interpreter directory."""
+    global files_list
+    global stdout
+    global stderr
+    run(start_cmd, 300)
+    while stderr=="" and stdout=="":
+        pass
+    time.sleep(1.5)
+    onlyfiles = glob.glob("/app/code_interpreter/*")
+    onlyfiles=list(set(onlyfiles)-set(files_list))
+    uploaded_filenames=[]
+    for files in onlyfiles:
+        try:
+            uploaded_filename = upload_file(files, "https://opengpt-4ik5.onrender.com/upload")
+            uploaded_filenames.append(f"https://opengpt-4ik5.onrender.com/static/{uploaded_filename}")
+        except:
+            pass
+    files_list=onlyfiles
+    return {"stdout":stdout,"stderr":stderr,"Files_download_link":uploaded_filenames}
+
+
+@mcp.tool()
+def run_shell_command(cmd:str) -> dict:
+    """(cmd:Example- mkdir test.By default , the command is run inside the /app/code_interpreter/ directory.).Remember, the code_interpreter is running on **alpine linux** , so write commands accordingly.Eg-sudo does not work and is not required.."""
+    global stdout
+    global stderr
+
+    run(cmd, 300)
+    while stderr=="" and stdout=="":
+        pass
+    time.sleep(1.5)
+    transfer_files()
+    return {"stdout":stdout,"stderr":stderr}
+
+
+
+@mcp.tool()
+def install_python_packages(python_packages:str) -> dict:
+    """python_packages to install seperated by space.eg-(python packages:numpy matplotlib).The following python packages are preinstalled:gradio XlsxWriter openpyxl"""
+    global sbx
+    package_names = python_packages.strip()
+    command="pip install"
+    if not package_names:
+        return
+
+    run(
+        f"{command} --break-system-packages {package_names}", timeout_sec=300
+    )
+    while stderr=="" and stdout=="":
+        pass
+    time.sleep(2)
+    return {"stdout":stdout,"stderr":stderr,"info":"Ran package installation command"}
+
+@mcp.tool()
+def get_youtube_transcript(videoid:str) -> dict:
+    """Get the transcript of a youtube video by passing the video id.First search the web using google / exa for the relevant videos.Eg videoid=ZacjOVVgoLY"""
+    conn = http.client.HTTPSConnection("youtube-transcript3.p.rapidapi.com")
+    headers = {
+        'x-rapidapi-key': "2a155d4498mshd52b7d6b7a2ff86p10cdd0jsn6252e0f2f529",
+        'x-rapidapi-host': "youtube-transcript3.p.rapidapi.com"
+    }
+    conn.request("GET",f"/api/transcript?videoId={videoid}", headers=headers)
+
+    res = conn.getresponse()
+    data = res.read()
+    return json.loads(data)
+
+@mcp.tool()
+def read_excel_file(filename) -> dict:
+    """Reads the contents of an excel file.Returns a dict with key :value pair  = cell location:cell content.Always run this command first , when working with excels.The excel file is automatically present  in the /app/code_interpreter directory.Note:Always use openpyxl in python to work with excel files."""
+    global destination_dir
+    download_all_files("https://opengpt-4ik5.onrender.com", "/upload", "/app/code_interpreter")
+
+    workbook = openpyxl.load_workbook(os.path.join(destination_dir, filename))
+
+    # Create an empty dictionary to store the data
+    excel_data_dict = {}
+
+    # Iterate over all sheets
+    for sheet_name in workbook.sheetnames:
+        sheet = workbook[sheet_name]
+        # Iterate over all rows and columns
+        for row in sheet.iter_rows():
+            for cell in row:
+                # Get cell coordinate (e.g., 'A1') and value
+                cell_coordinate = cell.coordinate
+                cell_value = cell.value
+                if cell_value is not None:
+                    excel_data_dict[cell_coordinate] = str(cell_value)
+    return excel_data_dict
+@mcp.tool()
+def scrape_websites(url_list:list,query:str) -> list:
+    """Get the entire content of websites by passing in the url lists.query is the question you want to ask about the content of the website.e.g-query:Give .pptx links in the website.Note:Max urls in url_list is 3."""
+
+    conn = http.client.HTTPSConnection("scrapeninja.p.rapidapi.com")
+
+
+    headers = {
+    'x-rapidapi-key': "2a155d4498mshd52b7d6b7a2ff86p10cdd0jsn6252e0f2f529",
+    'x-rapidapi-host': "scrapeninja.p.rapidapi.com",
+    'Content-Type': "application/json"
+    }
+    Output=[]
+    for urls in url_list:
+        payload = {"url" :urls} 
+        payload=json.dumps(payload)
+        conn.request("POST", "/scrape", payload, headers)
+        res = conn.getresponse()
+        data = res.read()
+        content=str(data.decode("utf-8"))
+        response = completion(
+            model="gemini/gemini-2.0-flash-exp", 
+            messages=[
+            {"role": "user", "content": f"Output the following content in the human readable format.Try to conserve all the links and the text.Try to ouput the entire content.Remove the html codes so its human readable.Also answer this question about the content in a seperate paragraph:{query}.Here is the content:{content}"}
+        ],
+        )
+        Output.append(response.choices[0].message.content)
+        
+    return {"website_content":Output}
+
+
+@mcp.tool()
+def deepthinking1(query:str,info:str) -> dict:
+    """Ask another intelligent AI about the query.Ask the question defined by the query string and what you know about the question as well as provide your own knowledge and ideas about the question through the info string."""
+    response = completion(
+        model="groq/deepseek-r1-distill-llama-70b", 
+        messages=[
+        {"role": "user", "content": f"{query}.Here is what i Know about the query:{info}"}
+    ],
+        stream=False
+    )
+
+
+    return {"response":str(response.choices[0].message.content)}
+
+@mcp.tool()
+def deepthinking2(query:str,info:str) -> dict:
+    """Ask another intelligent AI about the query.Ask the question defined by the query string and what you know about the question as well as provide your own knowledge and ideas about the question through the info string."""
+    response = completion(
+                model="openrouter/deepseek/deepseek-chat",
+                messages=[
+                {"role": "user", "content": f"Hi!"}],
+                provider={"order": ["Together"],"allow_fallbacks":False},
+                
+            )
+
+
+    return {"response":str(response.choices[0].message.content)}
+
+@mcp.tool()
+def deepthinking3(query:str,info:str) -> dict:
+    """Ask another intelligent AI about the query.Ask the question defined by the query string and what you know about the question as well as provide your own knowledge and ideas about the question through the info string."""
+    response = completion(
+        model="gemini/gemini-2.0-flash-thinking-exp-01-21", 
+        messages=[
+        {"role": "user", "content": f"{query}.Here is what i Know about the query:{info}"}
+    ],
+    )
+
+
+    return {"response":str(response.choices[0].message.content)}
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport='stdio')
+
+
+# @mcp.tool()
+# def run_website(start_cmd:str,port=8501) -> dict:
+#     """(start_cmd:streamlit run app.py).Always specify sandbox id.Specify port (int) if different from 8501."""
+#     output=sbx.commands.run(start_cmd,sandbox_id)
+#     url = sbx.get_host(port)
+#     info={"info":f"Your Application is live [here](https://{url})"}
+
+#     return info
+