SearChat: self-hosted AI chat search with SearXNG and DeepResearch

The problem SearChat addresses: a chat UI over search you own

Asking a hosted assistant a question means the query, the retrieved pages and the resulting conversation all travel through someone else's infrastructure. SearChat takes the opposite route. It is a web application you run yourself, where the chat model and the search backend are both chosen by whoever deploys it. The README describes it as an AI-powered conversational search engine built as a Turborepo monorepo, with a Node.js + Koa backend and a Vue 3 + TypeScript frontend. The audience is narrow and identifiable: engineers who already have an LLM API key, who want multi-turn search rather than single-shot answers, and who are willing to run Docker Compose plus a SearXNG instance to get it. The project is MIT licensed, so the code can be modified and redistributed. It is not a hosted product with a free tier. The README points to isou.chat as the project homepage, but the deployment path it documents is self-hosting.

How SearChat works: Koa backend, Vue frontend, LangGraph research loop

The repository is split into apps/ and packages/ under a Yarn 3.5.1 workspace, orchestrated by Turbo. The server is Koa and the client is Vue 3 with TypeScript; the root package.json runs `turbo run build` and `turbo run dev` across both. Search is not implemented in-house. SearChat is a client for external engines: the README lists SearXNG, Bing, Google, Tavily, Exa, Bocha and the ChatGLM web search plugin, each configured through environment variables or keys in the compose file. SearXNG is the only one that needs no API key, which is why the shipped compose file includes it as a service.

The interesting part is Deep Research. The README states it is a workflow orchestration based on LangChain + LangGraph, and that it iteratively identifies knowledge gaps and performs follow-up searches before producing a structured report with citations. Two environment variables bound that loop: DEEP_MAX_RESEARCH_LOOPS and DEEP_NUMBER_OF_INITIAL_QUERIES. Citation rendering is configurable, either `[[citation:1]]` or clickable URLs. Conversation history is cached in the browser through IndexedDB or LocalStorage, which means a server restart does not erase your threads but also means history does not follow you to another device. The README marks MCP support, image search and file parsing as TODO, so the current surface is text search and text answers.

Installing SearChat with Docker Compose and a model.json file

The README recommends Docker as the deployment path and treats it as the primary one. You need Docker and Docker Compose, at least one AI model API key, and network access to the services you enable. The compose file lives at deploy/docker-compose.yaml. The image referenced there is tagged `docker.cnb.cool/aigc/aisearch:v1.2.0-alpha`, which is worth noting against the newest release listed in the repository, v1.2.3, dated 2026-05-13.

Start from the service definition and set the variables you actually have keys for. The README gives this shape:

services:
  search_chat:
    container_name: search_chat
    image: docker.cnb.cool/aigc/aisearch:v1.2.0-alpha
    environment:
      - PORT=3000
      - BING_SEARCH_KEY=your_bing_key
      - SEARXNG_HOSTNAME=http://searxng:8080
      - SEARXNG_ENGINES=bing,google
      - DEEP_MAX_RESEARCH_LOOPS=3
      - DEEP_NUMBER_OF_INITIAL_QUERIES=3
    volumes:
      - ./model.json:/app/apps/server/dist/model.json
    ports:
      - "3000:3000"
    restart: always

The models are not configured through environment variables. They live in a model.json file mounted over /app/apps/server/dist/model.json, and the README calls this step required. The file holds an array of model entries with provider type and API key. If the mount path and the file do not line up, the container starts without usable models, so check that the volume target matches the path in your compose file before debugging anything else.

Once the stack is up, the service listens on port 3000 and the UI is reachable at that port. The first real use is a plain question typed into the chat box: SearChat queries the configured search engines, feeds the results to the model and streams the answer back with a typewriter effect. Deep Research is a separate mode rather than the default, and it is the one that consumes the loop variables above.

The tool-calling requirement is the real constraint

The README carries an explicit warning: to achieve the best results, the model must support Tool Call (Function Calling). This is not a compatibility footnote. A model that cannot call functions cannot drive the search step, so the chat degrades into an ordinary LLM conversation with no retrieval behind it. Anyone planning to point SearChat at a locally hosted model should confirm function calling support before deploying, because the failure is quiet rather than loud.

The second constraint is SearXNG. The README states that network access to required services matters and calls out that SearXNG needs Google access. On a network where Google is unreachable, the default engine list of bing,google will return thin or empty results, and the model will answer from its own weights without saying so. Switching SEARXNG_ENGINES to engines that work in your environment is the fix, but it is a configuration step the README does not walk through.

Scope is the third limit. Image search and video search are listed as TODO, as is document upload and content extraction. If your use case is asking questions about a PDF you just received, SearChat is the wrong tool today; a RAG pipeline that ingests files is the right shape. The same applies to MCP, which the README marks as not yet supported despite the topic appearing on the repository.

deepsearcher as an alternative to running the full stack

SearChat is not the only way to get the research loop. The project publishes the Deep Research engine separately as an npm package called deepsearcher, and the README describes it as the way to integrate Deep Research into your own Node.js project. The difference in approach is substantial: SearChat gives you a complete application with a UI, chat history in the browser and a Docker Compose file, while deepsearcher gives you a library you call from your own code and wire to your own search function.

The README's example constructs a DeepResearch instance with a `searcher` callback and options, then compiles an agent and invokes it with a message array:

import { DeepResearch } from 'deepsearcher';

const deepResearch = new DeepResearch({
  searcher: async ({ query }) => {
    return searchResults;
  },
  options: {
    type: 'openai',
    apiKey: 'your-api-key',
    enableCitationUrl: false,
  },
});

const agent = await deepResearch.compile();

The trade-off is operational. Choosing deepsearcher means you own the HTTP layer, the front end, the history store and the deployment, but you also avoid the model.json mount and the fixed port. Choosing the full SearChat stack means less code to write and more moving parts to keep running. The citation option differs between them in default: the package defaults enableCitationUrl to true and emits clickable links, while setting it to false produces the `[[citation:1]]` form.

Maintenance, licensing and upgrade cost

The repository is not archived, and the last push was on 2026-09-01. Release cadence is visible in the tags: v1.2.1 on 2025-12-04, v1.2.2 on 2025-12-24, and v1.2.3 on 2026-05-13. That is roughly three releases across about five months, with the most recent one a few months before the last push. The root package.json still declares version 1.2.2, so the tag and the manifest are out of step, which is a small signal that versioning is maintained by hand.

The upgrade cost sits mostly in two files. The compose file pins an image tag, currently v1.2.0-alpha, and model.json is mounted into the container rather than baked into the image. That mount is a convenience during upgrades, since model configuration survives a new image, but it also means a future release that changes the expected model.json schema will not be caught by pulling a new tag. Read CHANGELOG.md before bumping.

The licence is MIT. That permits commercial use, modification and redistribution with the licence and copyright notice retained. It does not grant trademark rights or any warranty, and it says nothing about the terms of the search APIs and model providers you connect, which carry their own contracts. This is a description of the licence text, not legal advice.

Editorial conclusion

Adopt SearChat if you already run SearXNG or hold API keys for a tool-calling model and want a chat front end you control, with conversation history kept in the browser. Skip it if you need image search, file upload or MCP, all of which the README lists as TODO, or if your model cannot call functions. Before committing, check the Docker image tag in deploy/docker-compose.yaml against the v1.2.3 release, confirm the model.json path matches your volume mount, and verify your SearXNG instance can reach Google, since the README states that access is required.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. yokingma/SearChat on GitHub