# coco-app is the Tauri client half of the Coco enterprise search platform

> Coco AI searches Google Workspace, Dropbox, Confluence and GitHub from one desktop and mobile app, with a team chat over the same corpus, and the indexing backend lives in a separate coco-server repository. The app is a Tauri 2.0 and React shell, so the real question for an adopter is whether you are willing to run the server too.

**infinilabs/coco-app** — 🥥 Coco AI App - Search, Connect, Collaborate, Personal AI Search and Assistant, all in one space.

- Repository: https://github.com/infinilabs/coco-app
- Website: https://coco.rs/
- Stars: 726 · Forks: 71
- Language: TypeScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/infinilabs-coco-app

## The repository holds the client, not the search engine

Coco AI is described as a unified search platform that connects enterprise applications and data, Google Workspace, Dropbox, Confluence Wiki, GitHub and more, into a single search interface. This repository contains the Coco App, built for both desktop and mobile, and the app lets users search and interact with enterprise data across platforms.

The boundary matters more than the feature list, and the README states it in a note near the top: backend services, including data indexing and search functionality, are handled in a separate repository, coco-server. So what you are looking at is the window, not the index. The client renders results, talks to the server over its API, and adds a Gen-AI chat for teams that is described as a ChatGPT-like assistant tailored to the team's own knowledge and internal resources.

That split defines the adoption question. A team that evaluates only this repository will not learn which connectors exist, how authentication is handled per tool, or what the search ranking does. Those answers live in the server repository and in the documentation sites for Coco App and Coco Server, both linked from the README.

## Tauri 2.0 with React, TypeScript and Tailwind

The stack is stated in the README's technology section: React and TypeScript on the frontend, Tauri 2.0 as the desktop framework, Tailwind CSS for styling, Zustand for state management and Vite as the build tool. The README also lists Rust as the language behind the performance claim, and the badge set shows Tauri 2.0, React 18, TypeScript 5, Rust latest and Node 18.12 or newer.

The choice of Tauri over an Electron shell is the architectural decision with the most consequences, because the app is a thin web view over a Rust core. The dependency list in package.json shows how much of the native surface the app wants: Tauri plugins for autostart, the clipboard manager, deep links, dialogs, global shortcuts, HTTP, logging, the opener, the operating system, the process and the shell. A global shortcut plugin and the deep link plugin are what make a desktop search launcher usable, and the autostart plugin is what lets it sit in the background ready to answer.

The app is also published for the web, and the README lists Windows, macOS, Linux and Web as the available platforms, with a `build:web` script in the package manifest that builds it as a separate npm package.

## Running it locally needs pnpm, Node and Rust

The prerequisites are Node.js 18.12 or newer, the latest stable Rust, and pnpm as the package manager. The development setup in the README is three commands:

```bash
# Install pnpm
npm install -g pnpm
```

```bash
# Install dependencies
pnpm install
```

```bash
# Start development server
pnpm tauri dev
```

That last command starts Vite for the frontend and the Tauri Rust backend together, so a first run also compiles Rust, which is where most of the waiting happens on a cold machine. A production build is a single command:

```bash
pnpm tauri build
```

The repository root also carries a `Makefile` that wraps the same flow, and it starts by checking the Node version before anything else runs:

```bash
	@echo "Checking Node.js version..."
	@node_version=$$(node -v | sed 's/v//'); \
	if [ "$$node_version" \< "$(NODE_VERSION_MIN)" ]; then \
		echo "Error: Node.js version must be at least $(NODE_VERSION_MIN)"; \
		exit 1; \
	fi
	@echo "Node.js version is adequate."
```

Note that the lock file in the repository is `pnpm-lock.yaml` while `package-lock.json` is also present, and the Makefile installs pnpm globally itself before running `pnpm install`. The example app directory `out/search-chat` referenced by the publish scripts is build output, not a source directory.

## The Makefile produces one installer per platform

Where the Tauri build command is generic, the Makefile is specific. The targets name the artefact rather than the framework, and each one maps to a Tauri bundle type.

For macOS there is a target for the plain `.app` bundle, one for a DMG, and one for a universal DMG built with `--target universal-apple-darwin`, which is the way to ship one binary set for both Intel and Apple Silicon. For Windows there are targets for an NSIS installer and an MSI package. For Linux there are targets for a deb and an rpm, and the file is cut off in the listing before the AppImage target. A commented line in the macOS target shows the Intel-only variant being switched off in favour of the universal build.

The pattern is worth copying even if you do not use this project. One target per artefact, each one a single `pnpm tauri build --bundles` invocation, means CI can build only what a release needs. The desktop development target also sets `RUST_BACKTRACE=1`, which is the difference between a useful panic message and a useless one when the Rust side fails during `pnpm tauri dev`.

## The web build is published as an npm package

The package manifest shows a second distribution channel with its own scripts:

```json
    "publish:web": "cd out/search-chat && npm publish",
    "publish:web:beta": "cd out/search-chat && npm publish --tag beta",
    "publish:web:alpha": "cd out/search-chat && npm publish --tag alpha",
    "publish:web:rc": "cd out/search-chat && npm publish --tag rc",
    "publish:web:otp": "cd out/search-chat && npm publish --access public --otp $NPM_OTP",
    "preview": "vite preview",
    "tauri": "tauri",
    "release": "release-it",
    "release-rc": "release-it --preRelease=rc --preReleaseBase=1",
    "release-beta": "release-it --preRelease=beta --preReleaseBase=1"
```

Three things follow. The web client is built into `out/search-chat` by `tsx scripts/buildWeb.ts` and published from there, so the npm package is a build artefact rather than the source tree. The channel scheme is wide, with beta, alpha and release candidate tags alongside the default, which is a lot of pre-release discipline for a project whose newest tag is v0.11.0. And releases are driven by release-it, with pre-release variants handled by separate script names.

The manifest also records the version as 0.10.0 while the repository's tags run ahead of it at v0.11.0, so the published npm version and the git tags are not the same numbering line, and a script-based version bump appears to be part of the release process rather than a manual edit.

## Search features live in the server, and the README admits it

The feature list in the README is where the boundary becomes visible. Unified search supports major collaboration platforms, offers real-time search across documents, conversations and files, and adds smart search intent understanding with relevance ranking and cross-platform data correlation with context display. The AI chat is described as a team-specific assistant trained on your enterprise data. Security is listed as support for private deployment and data sovereignty.

None of that runs in this repository. The README says so directly: backend services, including data indexing and search functionality, are handled in a separate repository, coco-server, and there is a second documentation site for it. So the search claims in the app's README describe the platform, and the app is the part that renders it.

Two consequences for a reader. First, an evaluation that stops at the app repository will not see the indexer, the per-service authentication flow or the ranking logic, and none of the README's search claims can be verified from this codebase alone. Second, the deployment story implied by the private deployment and data sovereignty features means you are expected to run the server yourself, which is a different commitment from installing a desktop app.

## Licence, releases and what to check first

The licence is MIT, and the README spells out what that allows in plain terms: you can freely use, modify and distribute the software for both personal and commercial purposes, including hosting it on your own servers. That last clause is the one that matters for an enterprise deployment, and it lines up with the private deployment and data sovereignty features listed earlier. This is not legal advice, and it is worth checking what Coco Server's own terms say, since the two are separate repositories.

Release history is brisk. The tags are v0.11.0 from 2026-06-23, v0.10.0 from 2025-12-19 and v0.9.1 from 2025-12-05, so v0.11.0 arrived in mid-2026 after a gap from the December 2025 releases, while the last push was on 2026-08-06. The project is not archived.

The repository also keeps its own working files: `docs/`, `scripts/`, `src/`, `src-tauri/`, `public/`, a `Makefile`, a `.release-it.ts` release configuration, a `components.json` file for UI components, Tailwind and PostCSS configuration, Vite and tsup configuration, and separate `tsconfig.json` and `tsconfig.node.json` files.

One caveat on the documentation. The README's own feature prose leans on promotional wording, and it does not document connector setup, authentication, or how the AI chat is scoped to a team, so treat those feature claims as the vendor's description rather than as something you can read the code to confirm from this repository alone.

## Conclusion

Adopt coco-app when your team needs one search surface across several SaaS tools and can also operate the coco-server backend, since indexing and search live there and the app is a client. Do not adopt it for a single-tool team, where a native search is cheaper, and do not read the app repository as a complete product. Verify first that the coco-server repository covers the connectors you need, that the version in package.json matches the tag you build from, given that package.json says 0.10.0 while the newest tag is v0.11.0 from 2026-06-23 and the last push was on 2026-08-06, and that your build machine has Node 18.12 or newer and a stable Rust toolchain.

## FAQ

### What does the coco-app repository contain?

It contains the Coco App, the Tauri 2.0 and React client built for desktop and mobile, which searches and interacts with enterprise data. The README states that backend services, including data indexing and search functionality, are handled in a separate coco-server repository.

### How do I run coco-app in development?

The README lists Node.js 18.12 or newer, the latest stable Rust and pnpm as prerequisites, then `npm install -g pnpm`, `pnpm install` and `pnpm tauri dev` to start the development server. A production desktop build is `pnpm tauri build`.

### Which enterprise applications does Coco AI connect to?

The README names Google Workspace, Dropbox, Confluence Wiki and GitHub, and says the platform connects enterprise applications and data into a single search interface with real-time search across documents, conversations and files.

### Can Coco AI be self-hosted?

The README lists support for private deployment and data sovereignty among the key features, and states that the MIT licence lets you use, modify and distribute the software including hosting it on your own servers. The backend services for indexing and search live in the separate coco-server repository.

## Sources

- [infinilabs/coco-app on GitHub](https://github.com/infinilabs/coco-app)
- [License: MIT](https://github.com/infinilabs/coco-app/blob/main/LICENSE)
- [Project website](https://coco.rs/)
- [README](https://github.com/infinilabs/coco-app/blob/main/README.md)
- [Releases](https://github.com/infinilabs/coco-app/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/infinilabs-coco-app