ConverZen - High-Performance AI, Simplified

Getting started

keywords: getting-started

links: https://converzen.de/docs/getting-started

We are striving to make your experience as pleasant as possible but we are in the early business stages so don't get upset if you encounter a hick-up. You will be rewarded with a bleeding edge experience.

Check out the Demo and Customer Projects

keywords: Demos, Demo-Bots, Zeno, Serena

links: https://converzen.de , https://gaylynmorgan.com

Talk to Zeno our chief architect & core developer. He can be a bit short but nobody knows more about the product than him. He can save you plenty of time reading through documents. Unfortunately he is usually a little pressed for time and can be harsh. Don't take it to heart, he is working hard to redefine the way we interact with our customers (not his tone though).

We might be taking the load of Zeno and supplying a more friendly Customer interaction bot in the near future. Keep your eyes peeled.

Or talk to Serena, Gaylyn Morgan's emphatic spiritual guide. Specially if you are stressed. She might even draw a Tarot card for you - if you ask nicely. She can help you with your private and business decisions or sell you a hypnotherapy or counselling session.

Read the Docs

keywords: documents, documentation, How-tos, faq

links: https://converzen.de/docs

If Zeno has no time for you, you might as well take a look yourself. We are trying to supply as much information as possible to make your decision easy.

Get in Touch

keywords: email, contact, talk-to-us

links: mailto:zeno@converzen.de

Talk to us, we are happy to get you on the way to an amazing intelligent chat experience.

Join the Pilot

keywords: models, pilot

links: https://converzen.de/pilot

Be brave, join the pilot and get access to bleeding edge technology today.

Technical / Stack

What is it built on ?

The Chat Server Backend Stack

Keywords: Rust, Axum, Tokio, Postgres, SQLx , Qdrant

links: https://converzen.de/docs/architecture

tec-stack: Rust, Tokio, Axim, Postgres, Qdrant

The ConverZen Chat Server is built for extreme performance and strict, multi-layered security. By leveraging Rust and the Tokio runtime, the system handles thousands of concurrent connections with minimal overhead, while Axum provides a modular, type-safe web framework. The data layer is equally robust: PostgreSQL (via SQLx) handles structured data with compile-time checked queries, while Qdrant serves as the high-performance vector engine, enabling millisecond-latency semantic search for your RAG features.

Security is enforced at the edge through a sophisticated, dual-token architecture implemented in middleware. General access is restricted via server-side API keys, while Admin access is secured by cryptographically signed JWT tokens. For end-user interactions, the server employs a granular Chat access model that requires both project-specific API keys and optionally client-bound JWTs. This ensures that every request is not only authenticated but also restricted to its specific "area of access" before it ever reaches your business logic.

This architecture represents a transition from "Chat with a Box" to a Dynamic Agentic Environment. By sitting a Function Processor atop a demand-loaded MCP Process Manager, we have
created a system that is both resource-efficient and contextually aware.

MCP Server

keywords: MCP, MCP-server,Plugins, bubblewrap, sandboxing, WenbASM, WASM

links: https://converzen.de/docs/architecture , https://chat.converzen.de/docs

tech-stack: rust, WebASM, websockets, https,

ConverZen MCP (Model Context Protocol) servers are Rust-built processes that provide a specific set of typically user specific functions to a chat persona: eg. a MCP server could deliver an interface to your product database for the agent.

Currently ConverZen is working with stdio MCP servers - meaning the interface between the MCP-Server and the Chat server are their stdin/stdout streams. HTTP- and Websocket MCP-Servers are work in progress and will be available for high load applications soon.

The MCP servers multiplex request from several chat clients and execute them multi-threaded and asynchronously.

The actual functional interface, is loaded from plugins. The MCP server is merely a shell process, that enables communication, multithread processing and safety. Plugins are currently implemented as linux .so libraries with a defined functional interface.

There is an eco-system of rust libraries and macros and several samples that make creating plugins easy. Zeno's MCP-Plugin as well as the rust plugin development kit will soon be checked in to the ConverZen github account ( https://github.com/converzen ).

We have a WebASM plugin interface in the pipeline that we hope to release Q2/2026. This will allow plugin development any the WebASM compatible language of your choice.

MCP-plugins are categorised in one of several trust categories. 'un-trusted' externally provided plugins for instance will only be granted access to the required resources: eg. outbound https, restricted filesystem access (/tmp or a private directory) or a database connection via linux sockets. That way they are strictly separated from one another and from the system. This is achieved using iptables profiles for networking and bubblewrap for file-system and functional restrictions.

For a detailed MCP security concept see https://converzen.de/docs/MCP-Security-Architecture .

The Chat Widget

keywords: chat-widget, cvz-widget.js, Chat-Interface, Chat-Client

tech-stack: react, react-markdown, tailwind

links: https://converzen.de/docs/chat-widget , https://github.com/converzen/chat-widget

The chat widget is the easy access path to connect your clients to ConverZen. Instead of building your own streaming compatible interface and keeping it up to date with innovations on the ConverZen side of things, you can use our widget and always be using the latest features. You can integrate it:

out of the box
as an npm module
as a git-hub fork with your own modifications.

cvz-widget It is built in typescript using Preact (a lean React Engine) as the engine. There are 3 ways to integrate it:

Integrate it into your own web-app or web-page using:

The Effortless <script ..> method

This gives you a running chat widget even on a static website virtually within minutes.

Example :

<!DOCTYPE html>
<html>
...
<body>
  <h1>Welcome</h1>
  <!-- Include the widget -->
  <script
          async
          src="https://converzen.de/widget/latest/cvz-widget-md.js"
          id="cvz-widget-script"
  ></script>
  <!-- Initialize -->
</body>

Annother little script section to initialize the script with your preferences and you api-key and you are connected.

The npm package

Use the npm module manager to load the widget into your web app source code and plug it in wherever you want.

The github fork

cvz-widget is open source. Dowload the widget from github: https://github.com/converzen/chat-widget

ConverZen Admin

keywords: chat-admin, admin-interface, persona-creation, configuration, administration

tech-stack: next.js, react, tailwind

links: https://converzen.de/docs/chat-widget , https://github.com/converzen/chat-widget

The ConverZen Chat Admin interface allows users of different levels to access the configuration interfaces of the Chat Server.

Available Interfaces

Persona Creation, Modification and Submission
Document upload, management
RAG collection management, RAG test interface
Chat test interface
Api-key management
Billing, Payment,
User profile & Account management
User management

The admin uses the chat server as back-end - it is merely a web interface to the API-endpoints supplied by the chat server.

There are 4 basic user levels: Admin account members

admin - the all-mighty super-user has access to pretty much everything, super-powers are:
- customer account creation and administration
- initial customer admin/user invitations
user - a user that can be invited to customer accounts for configuration or troubleshooting tasks.

Customer account members

admin - customer admin users have access to:
- api-key generation,
- accounting, payment interfaces,
- persona submission to production
- account user invitation
- persona / rag
user - customer user accounts can modify and test:
- create, modify and test development personas (version_type: 'next'),
- RAG: add, remove settings / documents,
- Document upload/management

All users are created by invitation only. Only admin accounts (customer-admin, super) can issue invitations. The recipient of an invitation can act on it within a limited time and consume the invitation using the invited email account.

The invitation determines the customer account and the user type. 2FA is mandatory for ConverZen Admin users.

How does it Work

The Tool/Function Interface: Bridging Personas and Capabilities

keywords: Function Processor, MCP Orchestration, Agentic-RAG

The Function Processor acts as the cognitive gateway between your active chat personas and the underlying server capabilities. Tools are handed to the LLM together with the users queries, giving the LLM a choice of functions to call.

When a persona identifies a need—such as retrieving specific product details—the Function Processor coordinates with the MCP Process Manager to spin or connect to the MCP-Server that runs the required plugin (e.g., your Rust or WASM interface to Customer specific functions or data), execute the logic within a secure sandbox, and return a structured response. This separation ensures that the LLM only interacts with high-level "intent" while the server handles the heavy lifting of security, process lifecycle, and data integrity.

The Function Processor als identifies local requests like Agentc RAG or other requests that are handled locally and short-cuts them to the RAG Collection Interface defined for the persona.

MCP Ecosystem

Keywords: Agentic-RAG, MCP, Process-Manager, Bubblewrap, iptables

By integrating Agentic RAG directly into this interface, the chatbot evolves from a passive retriever to an active researcher. Unlike traditional RAG, which blindly injects data into every prompt, the Agentic approach allows the persona to decide if and when to consult the knowledge base. The Function Processor exposes the RAG interface as a standard MCP Tool, enabling the persona to refine its own search queries based on the flow of dialogue. Because the MCP Process Manager can demand-load specialized plugins—such as a dedicated Qdrant vector searcher or a keyword-similarity engine—Zeno can switch between broad documentation sweeps and precise "morsel" lookups with millisecond latency, all while remaining enclosed in a secure, isolated execution environment.

Why Rust ?

What sets Rust apart?

Rust is a modern systems programming language that solves the "safety vs. performance" trade-off. Historically, developers had to choose between the raw speed of C/C++ (which risks memory crashes) and the safety of languages like Java or Python (which use "Garbage Collectors" that can slow things down). Rust provides a third way: it uses a unique Ownership and Borrowing system to guarantee memory safety at compile-time. This means Zeno’s backend can run with the speed of a native binary while being virtually immune to common security vulnerabilities like buffer overflows or data races.

Key Advantages

Zero-Cost Abstractions: You can write high-level, expressive code without paying a performance penalty.
Memory Safety Without GC: No garbage collector means no "stop-the-world" pauses, resulting in predictable, low-latency performance.
Fearless Concurrency: The compiler prevents data races, making it much easier to build multi-threaded applications that don't crash.
Modern Tooling: The built-in manager, Cargo, simplifies everything from dependency management to automated testing and documentation.

Business

How to purchase

keywords: purchase, subscription, partnership

links: https://converzen.de/pilot

Right now ConverZen is still work in progress in some areas. Nevertheless we are offering to build Chat Integrations for selected customers. You can choose between 3 different partnership models. Please visit https://converzen.de/pilot for details.

Partnership models:

Tier 01 - The Rapid Prototype

Fixed Fee Starting at €1,000

What's Included:

One specific use-case (e.g., Doc-Chat)
Basic RAG setup
Basic MCP Server integration
4-week trial of the Rust server

Tier 02 - The Implementation Partner

As much diy as you want.

Hourly rates €80/hr for development support.

Get expert help with:

Basic setup
MCP server & RAG setup
Ongoing custom development
Custom plugin creation
Deep infrastructure integration

Tier 03 - The Full-Stack Pilot

Retainer €3,500/mo