AgenticSeek: Running Manus AI Locally with Deepseek & Qwen (Open Source Tool)

In the rapidly evolving landscape of Artificial Intelligence, tools that offer privacy, local control, and powerful capabilities are increasingly sought after. AgenticSeek emerges as a compelling solution, providing a 100% local alternative to cloud-based AI assistants like Manus AI. This open-source tool empowers users to leverage the prowess of Large Language Models (LLMs) such as Deepseek and Qwen directly on their own hardware. This comprehensive tutorial will guide you through understanding AgenticSeek, its installation, configuration, and usage, enabling you to harness its potential for autonomous web browsing, coding assistance, and complex task planning – all while ensuring your data remains private and secure.

Tired of Postman? Want a decent postman alternative that doesn't suck?

Apidog is a powerful all-in-one API development platform that's revolutionizing how developers design, test, and document their APIs.

Unlike traditional tools like Postman, Apidog seamlessly integrates API design, automated testing, mock servers, and documentation into a single cohesive workflow. With its intuitive interface, collaborative features, and comprehensive toolset, Apidog eliminates the need to juggle multiple applications during your API development process.

Whether you're a solo developer or part of a large team, Apidog streamlines your workflow, increases productivity, and ensures consistent API quality across your projects.

Why AgenticSeek? The Power of Local AI

AgenticSeek distinguishes itself by offering a suite of features centered around local operation and user control:

• 🔒 Fully Local & Private: In an era where data privacy is paramount, AgenticSeek shines. Every component, from the AI models to your interactions, runs on your machine. This means no cloud servers, no data sharing with third parties, and complete confidentiality for your files, conversations, and web searches. Your digital footprint remains firmly within your control.
• 🌐 Smart Web Browsing: Imagine an assistant that can autonomously navigate the internet. AgenticSeek can perform web searches, read articles, extract specific information, and even fill out web forms – all without manual intervention. This hands-free browsing capability opens up new avenues for research and information gathering.
• 💻 Autonomous Coding Assistant: For developers and programmers, AgenticSeek offers a powerful coding partner. It can write, debug, and execute programs in a variety of languages including Python, C, Go, and Java. This autonomous coding capability can significantly boost productivity and assist in tackling complex programming challenges.
• 🧠 Smart Agent Selection: AgenticSeek incorporates an intelligent routing system. When you present a task, it automatically determines and deploys the most suitable AI agent for the job. This is akin to having a specialized team of experts at your disposal, ready to assist with diverse requests.
• 📋 Plans & Executes Complex Tasks: Beyond simple queries, AgenticSeek can manage and execute multi-step projects. Whether it's planning a trip, organizing research, or managing a complex workflow, it can break down large tasks into manageable steps and utilize multiple AI agents to see them through to completion.
• 🎙️ Voice-Enabled Interaction: Enhancing the user experience, AgenticSeek supports voice commands and speech-to-text functionality. This allows for a more natural and intuitive way to interact with your AI assistant, reminiscent of futuristic AI companions.

The core philosophy of AgenticSeek is to provide a robust, private, and versatile AI assistant that users can trust and customize. It draws inspiration from assistants like Jarvis and Friday from popular culture, aiming for a seamless and powerful user experience, while functionally mirroring the capabilities of tools like Manus AI but with a strong emphasis on local deployment.

Getting Started: Installation and Setup

To begin your journey with AgenticSeek, ensure your system meets the basic prerequisites: Python 3.10, Docker, Docker Compose, and Google Chrome. While other Python versions might work, Python 3.10.0 is highly recommended to avoid potential dependency issues.

Step 1: Clone the Repository

First, clone the AgenticSeek repository from GitHub and navigate into the project directory. You'll also need to create a .env file from the provided example, which will store essential environment variables.

git clone https://github.com/Fosowl/agenticSeek.git
cd agenticSeek
mv .env.example .env

Step 2: Create a Virtual Environment

It's best practice to use a virtual environment to manage project dependencies. Create and activate one as follows:

python3 -m venv agentic_seek_env
source agentic_seek_env/bin/activate
# On Windows: agentic_seek_env\Scripts\activate

Step 3: Install Dependencies

AgenticSeek offers both automatic and manual installation methods.

Automatic Installation (Recommended):

This is the simplest way to get up and running.

• For Linux/macOS:

  ./install.sh
  

• For Windows:

  ./install.bat
  

Manual Installation:

If you prefer or need to install dependencies manually, follow these platform-specific instructions. A crucial step for all operating systems is to ensure your installed ChromeDriver version matches your Google Chrome browser version. You can check your Chrome version by typing chrome://version in your browser's address bar or running google-chrome --version in your terminal.

• Linux:

  1. Update your package list: sudo apt update
  2. Install system dependencies: sudo apt install -y alsa-utils portaudio19-dev python3-pyaudio libgtk-3-dev libnotify-dev libgconf-2-4 libnss3 libxss1
  3. Install ChromeDriver matching your Chrome version: sudo apt install -y chromium-chromedriver (Alternatively, download from the official ChromeDriver site if the repository version is incompatible).
  4. Install Python requirements: pip3 install -r requirements.txt

• macOS:

  1. Update Homebrew: brew update
  2. Install ChromeDriver: brew install --cask chromedriver
  3. Install PortAudio (for voice functionality): brew install portaudio
  4. Upgrade pip and related tools: python3 -m pip install --upgrade pip setuptools wheel
  5. Install Python requirements: pip3 install -r requirements.txt

• Windows:

  1. Install pyreadline3: pip install pyreadline3
  2. Install PortAudio manually (e.g., via vcpkg or prebuilt binaries).
  3. Install PyAudio: pip install pyaudio
  4. Download and install ChromeDriver manually from the official ChromeDriver downloads page or older versions site. Ensure it matches your Chrome version.
  5. Place the chromedriver.exe in a directory included in your system's PATH environment variable.
  6. Install Python requirements: pip3 install -r requirements.txt

Chromedriver Note: If you encounter issues with ChromeDriver, particularly version mismatches (e.g., "session not created: This version of ChromeDriver only supports Chrome version X"), you must download the correct version. For Chrome versions 115 and newer, use the Chrome for Testing availability dashboard. For older versions, refer to the ChromeDriver downloads page.

Configuring AgenticSeek for Local LLM Execution

One of AgenticSeek's key strengths is its ability to run powerful LLMs like Deepseek and Qwen locally. This requires adequate hardware and proper configuration.

Hardware Requirements for Local LLMs

Running LLMs on your own machine demands significant computational resources, primarily GPU VRAM. Here’s a general guideline:

Deepseek R1 models are generally favored for their strong reasoning and tool-use capabilities relative to their size.

Setting Up Your Local LLM Provider

AgenticSeek supports several local LLM providers. Ollama is a popular choice for its ease of use.

1. Install and Start Your Provider:
   • If using Ollama, download and install it from the Ollama website.
   • Start the Ollama service:

     ollama serve
     

   • Pull your desired model (e.g., Deepseek or Qwen). For example, to get a 14B Deepseek model:

     ollama pull deepseek-coder:14b # Or other variants like deepseek-llm, etc.
     ollama pull qwen:14b
     

     Refer to the Ollama library for available model tags.

Updating the config.ini File

The config.ini file is the heart of AgenticSeek's configuration. You'll need to modify it to point to your local LLM setup.

[MAIN]
is_local = True                 # Set to True for local LLM operation
provider_name = ollama          # Or 'lm-studio', 'openai' (for local OpenAI-compatible servers)
provider_model = deepseek-coder:14b # Choose a model that fits your hardware (e.g., qwen:14b)
provider_server_address = 127.0.0.1:11434 # Default for Ollama
agent_name = Jarvis             # Name for your AI assistant (used for voice activation)
recover_last_session = True     # Resume previous session on startup
save_session = True             # Save session data
speak = True                    # Enable text-to-speech output
listen = False                  # Enable speech-to-text input (CLI only)
work_dir = /path/to/your/workspace # Directory AgenticSeek can read/write to
jarvis_personality = False      # Experimental: Use a more "Jarvis-like" personality
languages = en                  # List of languages for STT/TTS and routing (e.g., en zh)

[BROWSER]
headless_browser = True         # Run browser without a visible window (recommended for web UI)
stealth_mode = True             # Use undetected-chromedriver to reduce bot detection

Key config.ini Explanations:

• is_local: Must be True for local LLMs.
• provider_name: Set to your chosen local provider (ollama, lm-studio). If you're using a local server that exposes an OpenAI-compatible API (like llama.cpp server), you can use openai.
• provider_model: Specify the exact model name as recognized by your provider (e.g., deepseek-coder:14b for Ollama).
• provider_server_address: The address and port of your local LLM provider. For Ollama, it's typically 127.0.0.1:11434. For LM Studio, ensure you include http:// (e.g., http://127.0.0.1:1234).
• work_dir: This is the directory on your system that AgenticSeek will use as its workspace for creating files, saving outputs, etc. Ensure this path is correct and the application has write permissions.
• languages: Specify the languages you'll be interacting in. This helps the agent routing system.

Important Note for LM Studio Users: If using LM Studio, ensure provider_name is set to lm-studio and not openai. Also, the provider_server_address for LM Studio usually requires the http:// prefix (e.g., http://localhost:1234).

Running AgenticSeek with an API (Alternative to Local LLMs)

If your hardware isn't sufficient to run LLMs locally, or if you prefer to use cloud-based APIs, AgenticSeek supports this too. However, remember that this approach means your data will be processed by the API provider, sacrificing the "100% local" benefit.

Configuration for API Providers

1. Update config.ini:

   [MAIN]
   is_local = False                # Set to False for API usage
   provider_name = google          # Or 'openai', 'deepseek', 'huggingface', 'togetherAI'
   provider_model = gemini-1.5-flash # Or your chosen model from the provider
   provider_server_address = 127.0.0.1:5000 # Not critical for most APIs, can be a placeholder
   # ... other settings as preferred
   

   Warning: Avoid trailing spaces in your config.ini values.

2. Export Your API Key: You need to set an environment variable for your chosen provider's API key.

   export GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"
   # Or for other providers:
   # export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
   # export DEEPSEEK_API_KEY="YOUR_DEEPSEEK_API_KEY"
   # export HUGGINGFACE_API_KEY="YOUR_HUGGINGFACE_API_KEY"
   # export TOGETHER_API_KEY="YOUR_TOGETHER_API_KEY"
   

Supported API Providers:

A word of caution: The README suggests that models like GPT-4o may show poor performance for web browsing and task planning within AgenticSeek. Additionally, Gemini models might have issues with code generation or bash command execution due to prompt formatting incompatibilities.

Running AgenticSeek on a Remote Server

If you have a powerful machine (server) that can run the LLMs, but you want to interact with AgenticSeek from a different computer (e.g., your laptop), you can set up AgenticSeek's custom LLM server.

Server-Side Setup (Machine Running the LLM):

1. Get Server IP Address:
   • Linux: ip a | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | cut -d/ -f1 (for local network IP) or curl https://ipinfo.io/ip (for public IP).
   • Windows/macOS: Use ipconfig or ifconfig respectively.
2. Clone AgenticSeek Repository on Server:

   git clone --depth 1 https://github.com/Fosowl/agenticSeek.git
   cd agenticSeek/llm_server/
   

3. Install Server-Specific Requirements:

   pip3 install -r requirements.txt
   

4. Run the LLM Server Application:

   python3 app.py --provider ollama --port 3333
   

   You can choose ollama or llamacpp as the --provider for the server application. The --port can be any available port.

Client-Side Setup (Your Personal Computer):

1. Update config.ini on your client machine:

   [MAIN]
   is_local = False                # Set to False as the LLM is remote
   provider_name = server          # Special provider name for this setup
   provider_model = deepseek-r1:70b # The model running on your server
   provider_server_address = x.x.x.x:3333 # IP address and port of your server
   # ... other settings
   

   Replace x.x.x.x:3333 with the actual IP address and port of your LLM server.

Starting and Using AgenticSeek

Once configured, you're ready to run AgenticSeek.

Step 1: Activate Virtual Environment (if not already active)

source agentic_seek_env/bin/activate
# On Windows: agentic_seek_env\Scripts\activate

Step 2: Start Required Services

AgenticSeek relies on several services defined in docker-compose.yml, including SearXNG (a private meta-search engine) and Redis.

• For Linux/macOS:

  sudo ./start_services.sh
  

• For Windows:

  start ./start_services.cmd
  

  (You might need to run this as Administrator).

Step 3: Run AgenticSeek

You have two main options for interacting with AgenticSeek:

Option 1: Command-Line Interface (CLI)

python3 cli.py

For CLI mode, it's often better to see the browser in action, so you might want to set headless_browser = False in config.ini.

Option 2: Web Interface

1. Start the backend API:

   python3 api.py
   

2. Open your web browser and navigate to http://localhost:3000/.

Interacting with AgenticSeek

Whether using the CLI or web interface, you can now give AgenticSeek tasks.

Example Queries:

• "Make a snake game in Python!"
• "Search the web for top cafes in Paris, France, and save a list of three with their addresses in paris_cafes.txt."
• "Write a Go program to calculate the factorial of a number, save it as factorial.go in your workspace."
• "Search my project_documents folder for all PDF files, summarize them, and save the summaries in summaries_report.txt."

Tips for Effective Queries:

AgenticSeek's agent routing system is still under development. To ensure the best results, be explicit in your requests.

• Instead of: "Do you know some good restaurants nearby?"
• Try: "Do a web search for the best Italian restaurants within a 5-mile radius of my current location and list their names and ratings."

To exit AgenticSeek in CLI mode, you can typically say or type "goodbye."

Speech-to-Text (Voice Input)

AgenticSeek offers speech-to-text functionality, currently optimized for English and primarily for CLI mode.

1. Enable in config.ini:

   listen = True
   

2. Set Agent Name (Trigger Word): The agent_name in config.ini acts as the wake word.

   agent_name = Friday
   

   Using common English names like "John" or "Emma" can improve recognition.
3. Usage:
   • When AgenticSeek is listening, you'll usually see a transcript or an indication.
   • Say the agent's name (e.g., "Friday") to activate it.
   • Clearly speak your query.
   • End your request with a confirmation phrase like "do it," "go ahead," "execute," "please," or "do you understand?" to signal AgenticSeek to process the command.

Understanding the config.ini in Detail

We've touched on several config.ini settings, but here's a more comprehensive breakdown:

[MAIN]
is_local = True/False           # True for local LLM, False for API/remote server
provider_name = ollama          # ollama, lm-studio, openai, deepseek, huggingface, togetherAI, google, server
provider_model = deepseek-r1:32b # Model identifier specific to the provider
provider_server_address = 127.0.0.1:11434 # Address for local providers or remote server
agent_name = Friday             # Wake word for voice commands
recover_last_session = True/False # Load previous session state
save_session = True/False       # Save current session state
speak = True/False              # Enable/disable text-to-speech voice output
listen = True/False             # Enable/disable speech-to-text voice input (CLI)
work_dir = /path/to/workspace   # AI's accessible working directory
jarvis_personality = True/False # Experimental: Toggles a different system prompt for the AI
languages = en zh               # Supported languages for routing and TTS/STT. Avoid too many.

[BROWSER]
headless_browser = True/False   # True to run browser without UI, False to show browser window
stealth_mode = True/False       # Attempts to make browser automation harder to detect. May require manual anti-captcha extension installation.

Troubleshooting Common Issues

• Chromedriver Mismatch:

  • Error: Exception: Failed to initialize browser: Message: session not created: This version of ChromeDriver only supports Chrome version X...
  • Solution: Download the ChromeDriver version that exactly matches your installed Google Chrome browser version. See the "Installation" section for links.

• Connection Adapters Issue (Often with LM Studio):

  • Error: Exception: Provider lm-studio failed: HTTP request failed: No connection adapters were found for '127.0.0.1:1234/v1/chat/completions'
  • Solution: Ensure your provider_server_address in config.ini includes the http:// prefix for LM Studio (e.g., http://127.0.0.1:1234).

• SearXNG Base URL Not Provided:

  • Error: ValueError: SearxNG base URL must be provided either as an argument or via the SEARXNG_BASE_URL environment variable.
  • Solution:
    1. Ensure you copied .env.example to .env during setup (mv .env.example .env).
    2. Alternatively, manually export the environment variable: export SEARXNG_BASE_URL="http://127.0.0.1:8080" (or add it to your shell's startup file like .bashrc or .zshrc).

• General LLM Errors (cli.py or api.py):

  • Ensure your local LLM service (e.g., ollama serve) is running.
  • Double-check that your config.ini settings (provider_name, provider_model, provider_server_address) correctly match your LLM provider's setup and the model you have downloaded/available.
  • Verify all dependencies from requirements.txt are installed in your active virtual environment.
  • Check the terminal output from both AgenticSeek and your LLM provider for more specific error messages.

Why Deepseek & Qwen with AgenticSeek?

AgenticSeek's documentation often mentions Deepseek (particularly Deepseek R1) and Qwen models. There are good reasons for this preference:

• Strong Reasoning and Tool Use: Models like Deepseek R1 have demonstrated excellent capabilities in understanding complex instructions, reasoning through problems, and effectively using "tools" (which, in AgenticSeek's context, can mean interacting with the browser, file system, or code execution environments). This is crucial for an autonomous agent.
• Performance for Size: These models often provide a good balance between performance and resource requirements, making them more accessible for local deployment compared to extremely large proprietary models.
• Openness (or Availability): Many variants of Deepseek and Qwen are available through platforms like Ollama, making them easy to download and run locally. While not all are fully "open source" in the traditional software sense, their accessibility for local use aligns with AgenticSeek's philosophy.
• Community and Fine-tuning: Active communities around these models often lead to better support, fine-tuned versions for specific tasks, and ongoing improvements.

While AgenticSeek can theoretically work with other LLMs (especially those compatible with Ollama or OpenAI APIs), the system prompts and internal logic may be optimized for the characteristics of models like Deepseek and Qwen.

Contributing to AgenticSeek

AgenticSeek is an open-source project, and contributions are welcome. If you're a developer interested in AI agents, local LLMs, or building privacy-focused tools, this is a great project to get involved with.

• Check Open Issues: Look for existing bugs, feature requests, or areas needing improvement on the project's GitHub issues page.
• Join the Discussion: Participate in discussions on the project's Discord server or GitHub discussions to share ideas or ask questions.
• Contribution Guidelines: Refer to the CONTRIBUTING.md file in the repository for detailed information on how to contribute, coding standards, and the development workflow. This typically includes information on:
  • Setting up a development environment.
  • Branching strategies.
  • Pull request procedures.
  • Code style and linting.
  • Testing.
• Code of Conduct: Familiarize yourself with the project's CODE_OF_CONDUCT.md to ensure a respectful and collaborative environment for all contributors.

Areas where contributions could be particularly valuable include:

• Improving the agent routing system.
• Enhancing the capabilities of existing agents (web browser, coder, planner).
• Adding support for new LLM providers or models.
• Improving the user interface (CLI and web).
• Expanding voice control features and language support.
• Developing more robust error handling and debugging tools.
• Creating more comprehensive documentation and tutorials.

The Future of Local AI with AgenticSeek

AgenticSeek represents a significant step towards democratizing powerful AI capabilities by bringing them directly to the user's hardware. By prioritizing privacy, local control, and open-source principles, it offers a compelling alternative in a world increasingly dominated by cloud-based AI services. As local LLMs like Deepseek and Qwen become more powerful and efficient, and as hardware continues to improve, tools like AgenticSeek will play an increasingly vital role in shaping how we interact with artificial intelligence.

Whether you're a developer looking to automate coding tasks, a researcher needing an autonomous web browsing assistant, or simply an AI enthusiast passionate about privacy and local control, AgenticSeek provides a versatile platform to explore the potential of localized AI. By following this tutorial, you should now be well-equipped to install, configure, and begin using this innovative open-source tool. Dive in, experiment, and perhaps even contribute to its exciting future!