agenticSeek

English | 中文 | 繁體中文 | Français | 日本語 | Português (Brasil) | Español | Türkçe

A 100% local alternative to Manus AI, this voice-enabled AI assistant autonomously browses the web, writes code, and plans tasks while keeping all data on your device. Tailored for local reasoning models, it runs entirely on your hardware, ensuring complete privacy and zero cloud dependency.

• 🔒 Fully Local & Private - Everything runs on your machine — no cloud, no data sharing. Your files, conversations, and searches stay private.

• 🌐 Smart Web Browsing - AgenticSeek can browse the internet by itself — search, read, extract info, fill web form — all hands-free.

• 💻 Autonomous Coding Assistant - Need code? It can write, debug, and run programs in Python, C, Go, Java, and more — all without supervision.

• 🧠 Smart Agent Selection - You ask, it figures out the best agent for the job automatically. Like having a team of experts ready to help.

• 📋 Plans & Executes Complex Tasks - From trip planning to complex projects — it can split big tasks into steps and get things done using multiple AI agents.

• 🎙️ Voice-Enabled - Clean, fast, futuristic voice and speech to text allowing you to talk to it like it's your personal AI from a sci-fi movie. (In progress)

Can you search for the agenticSeek project, learn what skills are required, then open the CV_candidates.zip and then tell me which match best the project

Disclaimer: This demo, including all the files that appear (e.g: CV_candidates.zip), are entirely fictional. We are not a corporation, we seek open-source contributors not candidates.

🙏 This project started as a side-project and has zero roadmap and zero funding. It's grown way beyond what I expected by ending in GitHub Trending. Contributions, feedback, and patience are deeply appreciated.

Before you begin, ensure you have the following software installed:

• Git: For cloning the repository. Download Git
• Python 3.10.x: We strongly recommend using Python version 3.10.x. Using other versions might lead to dependency errors. Download Python 3.10 (pick a 3.10.x version).
• Docker Engine & Docker Compose: For running bundled services like SearxNG.
  • Install Docker Desktop (which includes Docker Compose V2): Windows | Mac | Linux
  • Alternatively, install Docker Engine and Docker Compose separately on Linux: Docker Engine | Docker Compose (ensure you install Compose V2, e.g., sudo apt-get install docker-compose-plugin).

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

SEARXNG_BASE_URL="http://searxng:8080" # value depends on where the backend runs — see the SEARXNG note below
SEARXNG_PORT=8080
REDIS_BASE_URL="redis://redis:6379/0"
WORK_DIR="/Users/mlg/Documents/workspace_for_ai"
OLLAMA_PORT="11434"
LM_STUDIO_PORT="1234"
CUSTOM_ADDITIONAL_LLM_PORT="11435"
OPENAI_API_KEY='optional'
DEEPSEEK_API_KEY='optional'
OPENROUTER_API_KEY='optional'
TOGETHER_API_KEY='optional'
GOOGLE_API_KEY='optional'
ANTHROPIC_API_KEY='optional'

Update the .env file with your own values as needed:

• SEARXNG_PORT: The host port Docker publishes SearXNG on. If port 8080 is already taken on your machine, set another one (e.g. 8001). Inside Docker the container always listens on 8080 — this variable never changes that.
• SEARXNG_BASE_URL: The address the backend uses to reach SearXNG. It is set here in .env (not in config.ini) and depends only on where the backend runs:

To check SearXNG in a browser, always use the host port: http://localhost:<SEARXNG_PORT>. After changing .env, restart the backend — the file is only read at process start.

• REDIS_BASE_URL: Leave unchanged
• WORK_DIR: Path to your working directory on your local machine. AgenticSeek will be able to read and interact with these files.
• OLLAMA_PORT: Port number for the Ollama service.
• LM_STUDIO_PORT: Port number for the LM Studio service.
• CUSTOM_ADDITIONAL_LLM_PORT: Port for any additional custom LLM service.
• AGENTICSEEK_API_TOKEN (optional): Token the web UI must send to the backend API. If unset, the backend generates one on first start and reuses it.
• AGENTICSEEK_ALLOWED_HOSTS (optional): Comma-separated extra hostnames/IPs the backend answers to (default: localhost, 127.0.0.1 only). Needed only when you reach the backend via a LAN IP or hostname, together with REACT_APP_BACKEND_URL (e.g. 192.168.1.100).
• AGENTICSEEK_EXEC_UID (Docker): Agent commands run as this unprivileged uid. start_services.sh sets it to the owner of WORK_DIR. Linux users upgrading from an older version may need to run sudo chown -R $(id -u) "$WORK_DIR" once.

API Key are totally optional for user who choose to run LLM locally. Which is the primary purpose of this project. Leave empty if you have sufficient hardware

Make sure Docker is installed and running on your system. You can start Docker using the following commands:

• On Linux/macOS: Open a terminal and run:

  sudo systemctl start docker

  Or launch Docker Desktop from your applications menu if installed.

• On Windows: Start Docker Desktop from the Start menu.

You can verify Docker is running by executing:

docker info

If you see information about your Docker installation, it is running correctly.

See the table of Local Providers below for a summary.

Next step: Run AgenticSeek locally

See the Troubleshooting section if you are having issues. If your hardware can't run LLMs locally, see Setup to run with an API. For detailed config.ini explanations, see Config Section.

Hardware Requirements:

To run LLMs locally, you'll need sufficient hardware. At a minimum, a GPU capable of running Magistral, Qwen or Deepseek 14B is required. See the FAQ for detailed model/performance recommendations.

Setup your local provider

Start your local provider (for example with ollama):

Unless you wish to to run AgenticSeek on host (CLI mode), export or set the provider listen address:

export OLLAMA_HOST=0.0.0.0:11434

Then, start you provider:

ollama serve

See below for a list of local supported provider.

Update the config.ini

Change the config.ini file to set the provider_name to a supported provider and provider_model to a LLM supported by your provider. We recommend reasoning model such as Magistral or Deepseek.

See the FAQ at the end of the README for required hardware.

[MAIN]
is_local = True # Whenever you are running locally or with remote provider.
provider_name = ollama # or lm-studio, openai, etc..
provider_model = deepseek-r1:14b # choose a model that fit your hardware
provider_server_address = 127.0.0.1:11434
agent_name = Jarvis # name of your AI
recover_last_session = True # whenever to recover the previous session
save_session = True # whenever to remember the current session
speak = False # text to speech
listen = False # Speech to text, only for CLI, experimental
jarvis_personality = False # Whenever to use a more "Jarvis" like personality (experimental)
languages = en zh # The list of languages, Text to speech will default to the first language on the list
[BROWSER]
headless_browser = True # leave unchanged unless using CLI on host.
stealth_mode = True # Use undetected selenium to reduce browser detection
import_user_profile = False # True: copy your own browser's logins into the agent browser (quit that browser first)
import_profile_name = Default # which of your browser's profile folders to import

Warning:

• The config.ini file format does not support comments. Do not copy and paste the example configuration directly, as comments will cause errors. Instead, manually modify the config.ini file with your desired settings, excluding any comments.

• Do NOT set provider_name to openai if using LM-studio for running LLMs. Set it to lm-studio.

• Some provider (eg: lm-studio) require you to have http:// in front of the IP. For example http://127.0.0.1:1234

List of local providers

Next step: Start services and run AgenticSeek

See the Troubleshooting section if you are having issues. If your hardware can't run LLMs locally, see Setup to run with an API. For detailed config.ini explanations, see Config Section.

This setup uses external, cloud-based LLM providers. You'll need an API key from your chosen service.

1. Choose an API Provider and Get an API Key:

Refer to the List of API Providers below. Visit their websites to sign up and obtain an API key.

2. Set Your API Key as an Environment Variable:

• Linux/macOS: Open your terminal and use the export command. It's best to add this to your shell's profile file (e.g., ~/.bashrc, ~/.zshrc) for persistence.

  export PROVIDER_API_KEY="your_api_key_here"
  # Replace PROVIDER_API_KEY with the specific variable name, e.g., OPENAI_API_KEY, GOOGLE_API_KEY

  Example for TogetherAI:

  export TOGETHER_API_KEY="xxxxxxxxxxxxxxxxxxxxxx"

• Windows:

  • Command Prompt (Temporary for current session):

    set PROVIDER_API_KEY=your_api_key_here

  • PowerShell (Temporary for current session):

    $env:PROVIDER_API_KEY="your_api_key_here"

  • Permanently: Search for "environment variables" in the Windows search bar, click "Edit the system environment variables," then click the "Environment Variables..." button. Add a new User variable with the appropriate name (e.g., OPENAI_API_KEY) and your key as the value.

  (See FAQ: How do I set API keys? for more details).

3. Update config.ini:

[MAIN]
is_local = False
provider_name = openai # Or google, deepseek, togetherAI, huggingface
provider_model = gpt-3.5-turbo # Or gemini-1.5-flash, deepseek-chat, mistralai/Mixtral-8x7B-Instruct-v0.1 etc.
provider_server_address = # Typically ignored or can be left blank when is_local = False for most APIs
# ... other settings ...

Warning: Make sure there are no trailing spaces in the config.ini values.

List of API Providers

Note:

• We advise against using gpt-4o or other OpenAI models for complex web browsing and task planning as current prompt optimizations are geared towards models like Deepseek.
• Coding/bash tasks might encounter issues with Gemini, as it may not strictly follow formatting prompts optimized for Deepseek.
• The provider_server_address in config.ini is generally not used when is_local = False as the API endpoint is usually hardcoded in the respective provider's library.

Next step: Start services and run AgenticSeek

See the Known issues section if you are having issues

See the Config section for detailed config file explanation.

By default AgenticSeek is run fully in docker.

Option 1: Run in Docker, use web interface:

Start required services. This will start all services from the docker-compose.yml, including: - searxng - redis (required by searxng) - frontend - backend (if using full when using the web interface)

./start_services.sh full # MacOS
start start_services.cmd full # Window

Warning: This step will download and load all Docker images, which may take up to 30 minutes. After starting the services, please wait until the backend service is fully running (you should see backend: "GET /health HTTP/1.1" 200 OK in the log) before sending any messages. The backend services might take 5 minute to start on first run.

Go to http://localhost:3000/ and you should see the web interface.

On first open, the web interface asks for an API token. Get it with docker compose logs backend | grep "API token" or docker exec backend cat /opt/agent-runtime/api_token (or set your own with AGENTICSEEK_API_TOKEN in .env). Paste it once; the browser remembers it.

Troubleshooting service start: If these scripts fail, ensure Docker Engine is running and Docker Compose (V2, docker compose) is correctly installed. Check the output in the terminal for error messages. See FAQ: Help! I get an error when running AgenticSeek or its scripts.

Option 2: CLI mode:

To run with CLI interface you would have to install package on host:

./install.sh
./install.bat # windows

Then you must change SEARXNG_BASE_URL in your .env file (not config.ini) to the host-mapped address, because in CLI mode the backend runs on your machine, outside Docker:

SEARXNG_BASE_URL="http://localhost:8080"

If you changed SEARXNG_PORT in .env, use that port here instead (e.g. http://localhost:8001). Restart cli.py after editing .env — the value is read at startup.

Start required services. This will start some services from the docker-compose.yml, including: - searxng - redis (required by searxng) - frontend

./start_services.sh # MacOS
start start_services.cmd # Window

Run: uv run: uv run python -m ensurepip to ensure uv has pip enabled.

Use the CLI: uv run cli.py

Make sure the services are up and running with ./start_services.sh full and go to localhost:3000 for web interface.

To give the agent your own files in the web interface, click the paperclip next to the send button and pick one or more files. When you send the message, the files are saved in WORK_DIR/.user_uploads/ (an existing file is never replaced: a second report.pdf becomes report (1).pdf; <, > and , in names become _), and their paths are added to your message, for example review this document <files>.user_uploads/report.pdf</files>. The limit is 50 MB per file.

You can also use speech to text by setting listen = True in the config. Only for CLI mode.

To exit, simply say/type goodbye.

Here are some example usage:

Make a snake game in python!

Search the web for top cafes in Rennes, France, and save a list of three with their addresses in rennes_cafes.txt.

Write a Go program to calculate the factorial of a number, save it as factorial.go in your workspace

Search my summer_pictures folder for all JPG files, rename them with today’s date, and save a list of renamed files in photos_list.txt

Search online for popular sci-fi movies from 2024 and pick three to watch tonight. Save the list in movie_night.txt.

Search the web for the latest AI news articles from 2025, select three, and write a Python script to scrape their titles and summaries. Save the script as news_scraper.py and the summaries in ai_news.txt in /home/projects

Friday, search the web for a free stock price API, register with [email protected] then write a Python script to fetch using the API daily prices for Tesla, and save the results in stock_prices.csv

Note that form filling capabilities are still experimental and might fail.

After you type your query, AgenticSeek will allocate the best agent for the task.

Because this is an early prototype, the agent routing system might not always allocate the right agent based on your query.

Therefore, you should be very explicit in what you want and how the AI might proceed for example if you want it to conduct a web search, do not say:

Do you know some good countries for solo-travel?

Instead, ask:

Do a web search and find out which are the best country for solo-travel

If you have a powerful computer or a server that you can use, but you want to use it from your laptop, you can run the LLM on the remote machine with a standard LLM server (Ollama, or any OpenAI-compatible server such as llama.cpp's llama-server) and point AgenticSeek at it over the network. No AgenticSeek-specific code needs to run on the server.

On your "server" that will run the AI model, get the ip address

ip a | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | cut -d/ -f1 # local ip
curl https://ipinfo.io/ip # public ip

Note: For Windows or macOS, use ipconfig or ifconfig respectively to find the IP address.

Option 1: Ollama (recommended)

On the server, install Ollama, start it so it accepts connections from your network, and pull your model:

OLLAMA_HOST=0.0.0.0 ollama serve
ollama pull deepseek-r1:14b

On your personal computer, change config.ini:

[MAIN]
is_local = False
provider_name = ollama
provider_model = deepseek-r1:14b
provider_server_address = x.x.x.x:11434

is_local must be False here: with True, AgenticSeek looks for Ollama on the machine it runs on and ignores the address.

Option 2: llama.cpp or any other OpenAI-compatible server

On the server, start llama.cpp's llama-server with your GGUF model (LM-Studio, vLLM or any other server exposing an OpenAI-compatible API works the same way):

llama-server -m your-model.gguf --host 0.0.0.0 --port 8080

On your personal computer, use the lm-studio provider — it speaks the plain OpenAI-compatible /v1/chat/completions API without requiring an API key:

[MAIN]
is_local = False
provider_name = lm-studio
provider_model = your-model
provider_server_address = http://x.x.x.x:8080

Legacy: custom AgenticSeek LLM server (deprecated)

Earlier versions shipped a custom Flask-based wrapper in llm_server/, used with provider_name = server. It is deprecated: it handles one request at a time, does not stream, offers no authentication, and the standard servers above do everything it did. It remains in the repository only for existing setups and may be removed in a future release.

Next step: Start services and run AgenticSeek

Warning: speech to text only work in CLI mode at the moment.

Please note that currently speech to text only work in english.

The speech-to-text functionality is disabled by default. To enable it, set the listen option to True in the config.ini file:

listen = True

When enabled, the speech-to-text feature listens for a trigger keyword, which is the agent's name, before it begins processing your input. You can customize the agent's name by updating the agent_name value in the config.ini file:

agent_name = Friday

For optimal recognition, we recommend using a common English name like "John" or "Emma" as the agent name

Once you see the transcript start to appear, say the agent's name aloud to wake it up (e.g., "Friday").

Speak your query clearly.

End your request with a confirmation phrase to signal the system to proceed. Examples of confirmation phrases include:

"do it", "go ahead", "execute", "run", "start", "thanks", "would ya", "please", "okay?", "proceed", "continue", "go on", "do that", "go it", "do you understand?"

Example config:

[MAIN]
is_local = True
provider_name = ollama
provider_model = deepseek-r1:32b
provider_server_address = http://127.0.0.1:11434 # Example for Ollama; use http://127.0.0.1:1234 for LM-Studio
agent_name = Friday
recover_last_session = False
save_session = False
speak = False
listen = False

jarvis_personality = False
languages = en zh # List of languages for TTS and potentially routing.
[BROWSER]
headless_browser = False
stealth_mode = False

Explanation of config.ini Settings:

• [MAIN] Section:
  • is_local: True if using a local LLM provider (Ollama, LM-Studio, local OpenAI-compatible server) or the self-hosted server option. False if using a cloud-based API (OpenAI, Google, etc.).
  • provider_name: Specifies the LLM provider.
    • Local options: ollama, lm-studio, openai (for local OpenAI-compatible servers). server is deprecated — see Setup to run the LLM on your own server.
    • API options: openai, google, deepseek, huggingface, togetherAI.
  • provider_model: The specific model name or ID for the chosen provider (e.g., deepseekcoder:6.7b for Ollama, gpt-3.5-turbo for OpenAI API, mistralai/Mixtral-8x7B-Instruct-v0.1 for TogetherAI).
  • provider_server_address: The address of your LLM provider.
    • For local providers: e.g., http://127.0.0.1:11434 for Ollama, http://127.0.0.1:1234 for LM-Studio.
    • For an LLM server on another machine: e.g., x.x.x.x:11434 for remote Ollama, http://x.x.x.x:8080 for a remote OpenAI-compatible server (see Setup to run the LLM on your own server).
    • For cloud APIs (is_local = False): This is often ignored or can be left blank, as the API endpoint is usually handled by the client library.
  • agent_name: Name of the AI assistant (e.g., Friday). Used as a trigger word for speech-to-text if enabled.
  • recover_last_session: True to attempt to restore the previous session's state, False to start fresh.
  • save_session: True to save the current session's state for potential recovery, False otherwise.
  • speak: True to enable text-to-speech voice output, False to disable.
  • listen: True to enable speech-to-text voice input (CLI mode only), False to disable.
  • work_dir: Crucial: The directory where AgenticSeek will read/write files. Ensure this path is valid and accessible on your system.
  • jarvis_personality: True to use a more "Jarvis-like" system prompt (experimental), False for the standard prompt.
  • languages: A comma-separated list of languages (e.g., en, zh, fr). Used for TTS voice selection (defaults to the first) and can assist the LLM router. Avoid too many or very similar languages for router efficiency.
• [BROWSER] Section:

  • headless_browser: True to run the automated browser without a visible window (recommended for web interface or non-interactive use). False to show the browser window (useful for CLI mode or debugging).

  • stealth_mode: True to enable measures to make browser automation harder to detect. May require manual installation of browser extensions like anticaptcha.

  • import_user_profile: True to copy the login sessions (cookies, localStorage, IndexedDB) of your own browser into the agent browser at the next start, so the agent is logged in where you are. That browser must be fully quit during the import, and the agent must run the same browser binary. If your daily browser is not Google Chrome, point both CHROME_EXECUTABLE_PATH and CHROME_USER_DATA_DIR at it (for Brave: CHROME_EXECUTABLE_PATH="/Applications/Brave Browser.app/Contents/MacOS/Brave Browser", CHROME_USER_DATA_DIR="$HOME/Library/Application Support/BraveSoftware/Brave-Browser"). Default False: this hands the agent your authenticated sessions (mail, bank). .browser_profile/ is gitignored; treat it as a secret.

  • import_profile_name: which of your browser's profile folders to import when you have more than one (chrome://version shows the folder name). Default Default.

Session import notes:

• Host only: the import needs your real browser data, so it works in CLI mode or api.py on the host. Keep import_user_profile = False when you run agenticSeek with Docker (./start_services.sh full).
• The import runs once per profile; the marker .browser_profile/session_import.json blocks repeats, and changing import_profile_name starts a new import at the next start. To redo it by hand: uv run python -m sources.browser_session_import "<profile-name>" (export the two CHROME_* variables in the shell first; this command does not read config.ini).
• After a fresh import, start once with headless_browser = False: macOS keychain consent and "new device" checks need a visible window.
• Your previous agent profile is kept at .browser_profile/chrome_data.bak-<date>; backups are never deleted automatically.
• The copy includes saved passwords (Login Data), autofill data (Web Data) and cookies, so the agent can act as you on those sites. With is_local = False, page content it reads is also sent to your cloud model provider.
• Passkeys never transfer; a few strict sites (some banks) may ask for one re-login inside the agent browser. Sessions your own browser can no longer decrypt do not transfer either.

This section summarizes the supported LLM provider types. Configure them in config.ini.

Local Providers (Run on Your Own Hardware):

API Providers (Cloud-Based):

• The backend API requires a token (AGENTICSEEK_API_TOKEN, auto-generated if unset). Only /health is public.
• The backend only answers to localhost/127.0.0.1 unless you add hosts in AGENTICSEEK_ALLOWED_HOSTS.
• In Docker, code the agent runs executes as an unprivileged user, and API keys/tokens/secrets are removed from its environment. Generated scripts no longer see provider API keys via env; pass a key explicitly if a script needs one.
• The backend container needs the NET_ADMIN capability (set in docker-compose.yml) to block agent code from loopback; without it the entrypoint prints a WARNING and agent code could reach chromedriver/Chrome DevTools.
• That code can still read and write everything in WORK_DIR and use the network: only mount folders you are fine exposing.
• safe_mode (on by default) is a best-effort command filter, not a sandbox.

If you encounter issues, this section provides guidance.

Error Example: SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version XXX

ChromeDriver version incompatibility occurs when:

1. Your installed ChromeDriver version doesn't match your Chrome browser version
2. In Docker environments, undetected_chromedriver may download its own ChromeDriver version, bypassing the mounted binary

Open Google Chrome → Settings > About Chrome to find your version (e.g., "Version 134.0.6998.88")

For Chrome 115 and newer: Use the Chrome for Testing API

• Visit the Chrome for Testing availability dashboard
• Find your Chrome version or the closest available match
• Download the ChromeDriver for your OS (Linux64 for Docker environments)

For older Chrome versions: Use the legacy ChromeDriver downloads

Method A: Project Root Directory (Recommended for Docker)

# Place the downloaded chromedriver binary in your project root
cp path/to/downloaded/chromedriver ./chromedriver
chmod +x ./chromedriver  # Make executable on Linux/macOS

Method B: System PATH

# Linux/macOS
sudo mv chromedriver /usr/local/bin/
sudo chmod +x /usr/local/bin/chromedriver

# Windows: Place chromedriver.exe in a folder that's in your PATH

# Test the ChromeDriver version
./chromedriver --version
# OR if in PATH:
chromedriver --version

⚠️ Important for Docker Users:

• The Docker volume mount approach may not work with stealth mode (undetected_chromedriver)
• Solution: Place ChromeDriver in the project root directory as ./chromedriver
• The application will automatically detect and use this binary
• You should see: "Using ChromeDriver from project root: ./chromedriver" in the logs

1. Still getting version mismatch?

   • Verify the ChromeDriver is executable: ls -la ./chromedriver
   • Check the ChromeDriver version: ./chromedriver --version
   • Ensure it matches your Chrome browser version

2. Docker container issues?

   • Check backend logs: docker logs backend
   • Look for the message: "Using ChromeDriver from project root"
   • If not found, verify the file exists and is executable

3. Chrome for Testing versions

   • Use the exact version match when possible
   • For version 134.0.6998.88, use ChromeDriver 134.0.6998.165 (closest available)
   • Major version numbers must match (134 = 134)

For the latest compatibility, check the Chrome for Testing dashboard

Exception: Failed to initialize browser: Message: session not created: This version of ChromeDriver only supports Chrome version 113 Current browser version is 134.0.6998.89 with binary path

This happen if there is a mismatch between your browser and chromedriver version.

You need to navigate to download the latest version:

https://developer.chrome.com/docs/chromedriver/downloads

If you're using Chrome version 115 or newer go to:

https://googlechromelabs.github.io/chrome-for-testing/

And download the chromedriver version matching your OS.

If this section is incomplete please raise an issue.

An error occurred: Provider ollama failed:
Ollama connection failed at http://host.docker.internal:11434. Check if the server is running.

The frontend shows Error: Unable to get a response. and the backend returns HTTP 500 on /query.

• Cause: When AgenticSeek runs in Docker, the backend reaches your host's Ollama via host.docker.internal. Only the port of provider_server_address is used in Docker mode; the host part is replaced by DOCKER_INTERNAL_URL from .env. So the failure is not a config typo — it's that Ollama on the host is only bound to 127.0.0.1:11434 and refuses connections coming in over the Docker bridge.

• Do NOT change provider_server_address = 127.0.0.1:11434 in config.ini — the host portion is ignored inside the container.

• Solution: Bind Ollama to all interfaces by setting OLLAMA_HOST=0.0.0.0:11434 on the host:

  Manual ollama serve:

  OLLAMA_HOST=0.0.0.0:11434 ollama serve

  Definitive solution:

  systemd (Linux):

  sudo systemctl edit ollama

  Add:

  [Service]
  Environment="OLLAMA_HOST=0.0.0.0:11434"
  

  Then:

  sudo systemctl daemon-reload
  sudo systemctl restart ollama

  macOS (Ollama.app):

  launchctl setenv OLLAMA_HOST "0.0.0.0:11434"

  Then quit and relaunch the Ollama app.

• Verify from inside the backend container:

  docker compose exec backend curl -sS http://host.docker.internal:11434/api/tags

  You should get a JSON list of models.

• Linux-only caveat: host.docker.internal only resolves inside the container if docker-compose maps it. Make sure the backend service in docker-compose.yml includes:

  extra_hosts:
    - "host.docker.internal:host-gateway"

  On Docker Desktop (macOS / Windows) this works out of the box.

• Firewall: if ufw / firewalld is active, allow the Docker bridge to reach 11434:

  sudo ufw allow from 172.16.0.0/12 to any port 11434

Exception: Provider lm-studio failed: HTTP request failed: No connection adapters were found for '127.0.0.1:1234/v1/chat/completions'` (Note: port may vary)

• Cause: The provider_server_address in config.ini for lm-studio (or other similar local OpenAI-compatible servers) is missing the http:// prefix or is pointing to the wrong port.
• Solution:
  • Ensure the address includes http://. LM-Studio typically defaults to http://127.0.0.1:1234.
  • Correct config.ini: provider_server_address = http://127.0.0.1:1234 (or your actual LM-Studio server port).

raise ValueError("SearxNG base URL must be provided either as an argument or via the SEARXNG_BASE_URL environment variable.")
ValueError: SearxNG base URL must be provided either as an argument or via the SEARXNG_BASE_URL environment variable.`

This might arise if you are running the CLI mode with the wrong base url for searxng.

SEARXNG_BASE_URL is set in .env and depends only on where the backend runs:

Backend on host (CLI mode): SEARXNG_BASE_URL="http://localhost:8080" — if you changed SEARXNG_PORT, use that port instead (e.g. http://localhost:8001). http://searxng:... does not work here: that hostname only resolves inside Docker.

Backend in Docker (web interface, full profile): SEARXNG_BASE_URL="http://searxng:8080" — always port 8080, even if you changed SEARXNG_PORT; that variable only remaps the host side.

Note on port conflicts: If port 8080 is already in use on your host, set SEARXNG_PORT (e.g. 8001) in .env, then:

• Web interface (backend in Docker): keep SEARXNG_BASE_URL="http://searxng:8080" — the internal Docker port does not change.
• CLI mode (backend on host): set SEARXNG_BASE_URL="http://localhost:8001" — it must match SEARXNG_PORT.
• Browser checks: open http://localhost:<SEARXNG_PORT> — whatever answers on the old port 8080 is some other application, not AgenticSeek's SearXNG.

After changing .env, restart the backend (api.py or cli.py) — the file is only read at process start.

Q: What hardware do I need?

Q: I get an error what do I do?

Ensure local is running (ollama serve), your config.ini matches your provider, and dependencies are installed. If none work feel free to raise an issue.

Q: Can it really run 100% locally?

Yes with Ollama, lm-studio or server providers, all speech to text, LLM and text to speech model run locally. Non-local options (OpenAI or others API) are optional.

Q: Why should I use AgenticSeek when I have Manus?

Unlike Manus, AgenticSeek prioritizes independence from external systems, giving you more control, privacy and avoid api cost.

Q: Who is behind the project ?

The project was created by me, along with two friends who serve as maintainers and contributors from the open-source community on GitHub. We’re just a group of passionate individuals, not a startup or affiliated with any organization.

Any AgenticSeek account on X other than my personal account (https://x.com/Martin993886460) is an impersonation.

We’re looking for developers to improve AgenticSeek! Check out open issues or discussion.

Contribution guide

Swiftproxy provides 90M+ clean residential IPs across 220+ locations, supporting HTTP(S)/SOCKS5, IP rotation, Sticky Sessions, and precise location targeting. It helps AI agents and automation tools access websites reliably from different locations, making it suitable for web browsing, data collection, research, and location-based testing.

Free testing is available, with 10% off using code PROXY90.

Want to level up AgenticSeek capabilities with features like flight search, trip planning, or snagging the best shopping deals? Consider crafting a custom tool with SerpApi to unlock more Jarvis-like capabilities. With SerpApi, you can turbocharge your agent for specialized tasks while staying in full control.

See Contributing.md to learn how to integrate custom tools!

Core (Agents, Tools, Systems, Searxng, Backend)

Fosowl | Paris Time

Frontend

Tanvir Ahamed For frontend design.

tcsenpai and plitc For helping with backend dockerization

Tanvir Ahamed For frontend design.