fount

⛲Imagination, Given Voice.✨

Stars: 874

Visit

fount is a character card frontend page that decouples AI sources, AI characters, user personas, dialogue environments, and AI plugins, allowing them to be freely combined to spark infinite possibilities. It serves as a bridge connecting imagination and reality, a lighthouse guiding characters and stories, and a free garden for AI sources, characters, personas, dialogue environments, and plugins to grow and bloom. It integrates AI sources without the need for reverse proxy servers, improves web experience with features like multi-device synchronization and unfiltered HTML rendering, and extends companionship beyond the web by connecting characters to Discord groups and providing gentle reminders through fount-pwsh. For character creators, fount offers infinite possibilities with JavaScript or TypeScript code customization, execution of code without filtering, loading npm packages, and creating custom HTML pages. It encourages extension through modularization and community contributions.

README:

⛲fount💪

Imagination, Given Voice.

What is fount?

fount is a modern, scalable AI agent runtime environment.

We believe that highly efficient productivity tools and immersive emotional interaction are not mutually exclusive. fount is a bridge: by day, it can be the capable assistant helping you write complex code and summarise meeting minutes; by night, it can be a digital confidant that understands your emotions and resonates with you.

After of dedicated refinement, incorporating the passion of , and a vibrant community with , fount is now a mature, stable, and continuously evolving AI interaction platform.

If you wish to configure, set up, and get started from scratch, you can refer to the community tutorial fount Guide for Dummies from Scratch (the tutorial is in Chinese, non-Chinese users can use the browser translation function to read it).

🚀 Efficiency and Engineering: Built for Professionals, Developers, and Geeks

fount transforms interaction into productivity assets. Everything is drag-and-drop, everything is a file, and logic is driven by code.

1. Knowledge Assetisation and Seamless Sharing

Instant Report Generation: Drag a conversation bubble directly to a folder to instantly generate an independent HTML report. This is ideal for quickly organising technical documents, meeting records, or fragments of inspiration.
Workflow Encapsulation and Distribution: Drag your created agent (role) directly to the desktop to generate a shareable file. Easily distribute your Prompt engineering and workflow logic to colleagues or the community.

2. Real-time Code Execution Environment

No longer just Markdown highlighting. In fount, the code blocks sent by the agent (role) are live.

Supports real-time compilation and running for multiple languages (C/C++/Rust/Python/JS, etc.).
Directly view stdout output, and even the ASM disassembly results for compiled languages.
Let the AI become your real-time verifier for pair programming.

3. Developer-Friendly

fount's project architecture is designed with full consideration for developers' habits. Want to know the project repository architecture? Check out DeepWiki!

Git Driven: All components can be managed via Git.
VSCode Integration: The project structure is clear. Combined with the guidance provided in AGENTS.md, you can develop and debug your Agent logic directly in your favourite IDE.

🎭 Immersion and Resonance: High-Fidelity Interaction Experience

When work is done, fount provides a connection that transcends the ordinary. We discard the stiffness of traditional tools, pursuing a natural, fluid, and deeply "high-fidelity" interaction.

Seamless Conversations, Anytime, Anywhere A chat started on a computer can seamlessly continue on a mobile phone or tablet. fount keeps your conversations synchronised, ensuring you stay closely connected with your agent no matter where you are.
Expressive, Immersive Chat Leveraging the power of HTML, fount allows the agent (role) to express itself through rich text, images, and even interactive elements, making every conversation vivid and profound.
A Gathering of Minds: Native Group Chat Invite multiple agents to join the same conversation and witness their dynamic and engaging interactions, whether for a work brainstorm or a story enactment between the agents.
Beautiful, Customisable Interface Choose from over 30 stunning themes, or create your own colours. fount is your exclusive canvas.
Available Everywhere fount runs seamlessly on Windows, macOS, Linux, and even Android, meeting your different needs through direct installation or the flexibility of Docker.
Unconstrained AI Source Integration: Embrace the Infinite fount offers unparalleled choice and flexibility in connecting AI sources. Custom JavaScript code in the AI Source Generator allows you to connect to any AI source – OpenAI, Claude, OpenRouter, NovelAI, Horde, Ooba, Tabby, Mistral... In the flow of code, you can carefully design complex regular expressions, call extensive API libraries, and embed multimedia resources. fount also natively supports the creation of API Pools to achieve intelligent request routing. The logic of communication follows your will, shaped by the power of code.

If you feel lost in the sea of agents, or are seeking forgotten stories, our vibrant and friendly community awaits your arrival. It is a haven for like-minded individuals, where developers and creators share their wisdom and creations.

Companionship: Beyond the Digital Veil

fount strives to weave characters into the very fabric of your life, offering companionship and support that transcends the screen.

Discord/Telegram Integration Connect your characters to Discord or Telegram communities through built-in Bot Shells, making them living members of your circles.
Browser Integration Integrate characters into browser extensions, allowing them to see and modify the content of pages in your browser, truly realizing "surfing the web with AI". You can say to your character: Hey XX, help me change the color of this page and add some decorations.
IDE Integration Integrate characters into IDEs like JetBrains, neovim, Zed, etc., allowing them to provide context-aware assistance and suggestions while you write code, just like Cursor Agent or GitHub Copilot.
Terminal Serenity (with fount-pwsh) When a terminal command falters, let your character offer a quiet word of guidance, easing the solitude of the digital world.
Limitless Shell Extensions With a touch of programming skill, craft your own fount Shells, extending your characters' reach to any corner you can imagine.

Creation: Beyond the Confines of Prompts

For the creator, fount offers a clearer path to bringing your AI characters to life.

Revolutionary AI-Assisted Creation Describe your character in a single sentence, and our intelligent AI assistant will craft a fully realised persona. This simplifies the initial setup, allowing you to focus on refining and interacting with your creation.
The Magic of Code, Easier Than You Imagine In fount, code is a form of modern magic. With the gentle guidance of our community and the illuminating aid of AI, learning it is surprisingly easy. You'll find that defining character logic with code can be an intuitive and maintainable way to craft characters whose responses are woven from your own logic.
Start with Ready-Made Magic: A Treasure Trove of Templates fount's community provides a wealth of pre-crafted character and persona templates. They act as "living blueprints," easy to adapt and customise, providing a fantastic starting point.
Embedded Resources Weave images, audio, and other resources directly into your characters, making their presence all the more tangible.
Continuous Integration Use fount-charCI to safeguard your character development. It automatically runs tests on commit and reports issues in real-time.
Legacy Compatibility fount embraces the past, offering compatibility modules to run SillyTavern and Risu character cards (though migration of existing characters is not supported).

Architecture: The Foundation of Innovation

fount is built upon a robust and scalable architecture. The backend leverages the power and speed of Deno, with Express for efficient routing. The frontend is crafted with HTML, CSS, and JavaScript for an intuitive and appealing interface.

Expansion: A Tapestry Woven from Diverse Threads

In the world of fount, modularity reigns supreme. A rich ecosystem of components intertwines to create the tapestry of your experience. All of these can be effortlessly installed, expanded, and customised by users.

chars (Characters): The heart of fount, where personalities are born.
worlds (Worlds): Far more than mere lorebooks. They are the silent architects of reality, able to append knowledge, influence decisions, and even manipulate chat history.
personas (User Personas): More than just user profiles. Personas possess the power to warp and even seize control of your words and perceptions, allowing for truly immersive roleplaying.
shells (Interaction Interfaces): The gateways to fount's soul, extending the reach of characters beyond the interface.
ImportHandlers (Import Handlers): The welcoming hands of fount, bridging the gap between diverse character formats.
AIsources (AI Sources): The raw power that fuels the minds of your characters.
AIsourceGenerators (AI Source Generators): The alchemists of fount, providing templates and logic via JavaScript to forge connections with any imaginable AI source.

Installation & Removal: An Elegant Encounter and Farewell

Installation: Weaving fount Into Your World – Effortlessly

[!TIP]

If you wish to configure, set up, and get started from scratch, you can refer to the community tutorial fount Guide for Dummies from Scratch (the tutorial is in Chinese, non-Chinese users can use the browser translation function to read it).

Embark on your journey with fount, a stable and reliable platform. A few simple clicks or commands, and the world of fount unfolds.

[!CAUTION] In the world of fount, characters can freely execute JavaScript commands, granting them powerful capabilities. Therefore, please choose the characters you trust with the same care you would in real life to ensure the safety of your local files.

Linux/macOS/Android: The Whispers of the Shell – One Line, and You're In

# If needed, define the environment variable $FOUNT_DIR to specify the fount directory
INSTALLED_PACKAGES="${FOUNT_AUTO_INSTALLED_PACKAGES:-}"
install_package() { _command_name="$1"; _package_list=${2:-$_command_name}; _has_sudo=""; _installed_pkg_name="" ; if command -v "$_command_name" >/dev/null 2>&1; then return 0; fi; if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then _has_sudo="sudo"; fi; for _package in $_package_list; do if command -v apt-get >/dev/null 2>&1; then $_has_sudo apt-get update -y; $_has_sudo apt-get install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pacman >/dev/null 2>&1; then $_has_sudo pacman -Syy --noconfirm; $_has_sudo pacman -S --needed --noconfirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v dnf >/dev/null 2>&1; then $_has_sudo dnf install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v yum >/dev/null 2>&1; then $_has_sudo yum install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v zypper >/dev/null 2>&1; then $_has_sudo zypper install -y --no-confirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v apk >/dev/null 2>&1; then if [ "$(id -u)" -eq 0 ]; then apk add --update "$_package"; else $_has_sudo apk add --update "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v brew >/dev/null 2>&1; then if ! brew list --formula "$_package"; then brew install "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pkg >/dev/null 2>&1; then pkg install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v snap >/dev/null 2>&1; then $_has_sudo snap install "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; done; if command -v "$_command_name" >/dev/null 2>&1; then case ";$FOUNT_AUTO_INSTALLED_PACKAGES;" in *";$_installed_pkg_name;"*) ;; *) if [ -z "$FOUNT_AUTO_INSTALLED_PACKAGES" ]; then FOUNT_AUTO_INSTALLED_PACKAGES="$_installed_pkg_name"; else FOUNT_AUTO_INSTALLED_PACKAGES="$FOUNT_AUTO_INSTALLED_PACKAGES;$_installed_pkg_name"; fi; ;; esac; return 0; else echo "Error: Failed to install '$_command_name' from any source." >&2; return 1; fi; }
install_package "bash" "bash gnu-bash"; install_package "curl"
export FOUNT_AUTO_INSTALLED_PACKAGES="$INSTALLED_PACKAGES"
curl -fsSL https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.sh | bash
. "$HOME/.profile"

Should you wish to pause, to gather your thoughts before the grand adventure (a dry run):

INSTALLED_PACKAGES="${FOUNT_AUTO_INSTALLED_PACKAGES:-}"
install_package() { _command_name="$1"; _package_list=${2:-$_command_name}; _has_sudo=""; _installed_pkg_name="" ; if command -v "$_command_name" >/dev/null 2>&1; then return 0; fi; if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then _has_sudo="sudo"; fi; for _package in $_package_list; do if command -v apt-get >/dev/null 2>&1; then $_has_sudo apt-get update -y; $_has_sudo apt-get install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pacman >/dev/null 2>&1; then $_has_sudo pacman -Syy --noconfirm; $_has_sudo pacman -S --needed --noconfirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v dnf >/dev/null 2>&1; then $_has_sudo dnf install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v yum >/dev/null 2>&1; then $_has_sudo yum install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v zypper >/dev/null 2>&1; then $_has_sudo zypper install -y --no-confirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v apk >/dev/null 2>&1; then if [ "$(id -u)" -eq 0 ]; then apk add --update "$_package"; else $_has_sudo apk add --update "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v brew >/dev/null 2>&1; then if ! brew list --formula "$_package"; then brew install "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pkg >/dev/null 2>&1; then pkg install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v snap >/dev/null 2>&1; then $_has_sudo snap install "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; done; if command -v "$_command_name" >/dev/null 2>&1; then case ";$FOUNT_AUTO_INSTALLED_PACKAGES;" in *";$_installed_pkg_name;"*) ;; *) if [ -z "$FOUNT_AUTO_INSTALLED_PACKAGES" ]; then FOUNT_AUTO_INSTALLED_PACKAGES="$_installed_pkg_name"; else FOUNT_AUTO_INSTALLED_PACKAGES="$FOUNT_AUTO_INSTALLED_PACKAGES;$_installed_pkg_name"; fi; ;; esac; return 0; else echo "Error: Failed to install '$_command_name' from any source." >&2; return 1; fi; }
install_package "bash" "bash gnu-bash"; install_package "curl"
export FOUNT_AUTO_INSTALLED_PACKAGES="$INSTALLED_PACKAGES"
curl -fsSL https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.sh | bash -s init
. "$HOME/.profile"

Windows: A Choice of Paths – Simplicity Itself

Direct and Uncomplicated (Recommended): Download the exe file from Releases and run it.

The Power of PowerShell:

# If needed, define the environment variable $env:FOUNT_DIR to specify the fount directory
irm https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.ps1 | iex

For a dry run:

$scriptContent = Invoke-RestMethod https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.ps1
Invoke-Expression "function fountInstaller { $scriptContent }"
fountInstaller init

Git Installation: For those who prefer a touch of magic

If you already have Git installed, embracing fount is as simple as running a script.

For Windows: Open your command prompt or PowerShell and simply double-click run.bat.
For Linux/macOS/Android: Open your terminal and execute ./run.sh.

Docker: Embracing the Container

docker pull ghcr.io/steve02081504/fount

Removal: A Graceful Farewell

fount remove

Encountering a Shadow? Fear Not

Should you encounter any difficulties on your journey, please reach out. We are here to help and are committed to resolving most issues within 10 minutes to 24 hours.

GitHub Issues: Report any bugs or suggest new features through GitHub Issues.
Discord Community: Join our vibrant Discord community for real-time support and discussions.

Your voice will be heard. Simply restart fount, and the shadows will dissipate.

Badges & Links: Let Creations Shine, Let the World Connect

The world of fount is more than words and code; it's a feast for the eyes and an invitation to connect. We have prepared exquisite badges and convenient links to make your fount components shine and allow others to easily discover your masterpieces.

fount Badges: The Seal of Glory

You can proudly display this badge in your repository or anywhere you wish to showcase your work. Find the SVG files of the fount logo here.

[![fount repo](https://steve02081504.github.io/fount/badges/fount_repo.svg)](https://github.com/topics/fount-repo)

[![fount character](https://steve02081504.github.io/fount/badges/fount_character.svg)](https://github.com/topics/fount-character)

Colour Format	Code
HEX	`#0e3c5c`
RGB	`rgb(14, 60, 92)`
HSL	`hsl(205, 74%, 21%)`

You can also use the Badge Adder to add the fount logo to any shields.io badge.

Automatic Installation Links: Magic at Your Fingertips

Imagine others installing your creations into their fount world with a single click. Simply combine your component's ZIP or Git repository link with fount's protocol link.

https://steve02081504.github.io/fount/protocol?url=fount://run/shells/install/install; + Your_Component_Link

Recommended Browsers: For a Perfect Encounter

fount's frontend is woven from modern web technologies, but not all browsers resonate perfectly with its soul. For the most serene and fluid experience, we recommend companions that are in harmony with fount's rhythm:

Google Chrome / Microsoft Edge / Opera: They move in sync with fount's spirit, offering the best performance and compatibility for an interaction as smooth as poetry.

Yet, some browsers walk a different path, and their encounter with fount may carry a note of dissonance:

Mozilla Firefox: It is like a stubborn wanderer, often unhurried in its embrace of new technologies, sometimes choosing to linger in the past forever. This insistence, however, can lead to certain regrets:
- Lacking support for speculationrules, each of fount's cold starts and protocol handlings will be 1-2 seconds slower than they should be—moments quietly stolen from you.
- The absence of support for CSS anchor positioning will leave some pages with a touch of imperfect dust, spoiling a mood that was meant to be pure.
- The lack of support for blocking="render" may cause fount pages to flicker upon loading, hurting your eyes.
- According to backend error reports, only in the world of Firefox do fount pages sometimes fall into mysterious errors or appear strange—when that happens, try refreshing; it might just dispel the mist.
Apple Safari: Its support for "emerging" (several years old) web standards might be a tad better than Firefox's, but not by much.
- Also lacking support for speculationrules, which means fount's startup will still carry a slight delay, wasting your precious moments.
Brave: While based on Chromium, its formidable shield of privacy can sometimes inadvertently obscure some of fount's light, affecting the normal operation of certain features.

Witness the Growth: fount's Star History

Contributors

In Conclusion: The Artisan's Touch

Beyond the whispers of AI, fount offers a deeper connection—the artisan's touch. Within our community, you'll find a wealth of pre-crafted character and persona templates, each a carefully sculpted foundation awaiting your unique vision to awaken it.

fount empowers you to create and interact with AI characters in a way that feels natural, immersive, and deeply personal. Whether you're a seasoned creator or just beginning your journey, fount welcomes you.

Join our welcoming community and discover the magic of breathing life into your imagination, supported by a mature platform and a dedicated team.

For Tasks:

Click tags to check more tools for each tasks

customize characters create dialogue connect characters improve web experience extend companionship

For Jobs:

web developer ai engineer software engineer game developer content creator

Alternative AI tools for fount

Similar Open Source Tools

fount

github

: 874

langroid

Langroid is a Python framework that makes it easy to build LLM-powered applications. It uses a multi-agent paradigm inspired by the Actor Framework, where you set up Agents, equip them with optional components (LLM, vector-store and tools/functions), assign them tasks, and have them collaboratively solve a problem by exchanging messages. Langroid is a fresh take on LLM app-development, where considerable thought has gone into simplifying the developer experience; it does not use Langchain.

github

: 3.2k

exospherehost

Exosphere is an open source infrastructure designed to run AI agents at scale for large data and long running flows. It allows developers to define plug and playable nodes that can be run on a reliable backbone in the form of a workflow, with features like dynamic state creation at runtime, infinite parallel agents, persistent state management, and failure handling. This enables the deployment of production agents that can scale beautifully to build robust autonomous AI workflows.

github

: 65

AiR

AiR is an AI tool built entirely in Rust that delivers blazing speed and efficiency. It features accurate translation and seamless text rewriting to supercharge productivity. AiR is designed to assist non-native speakers by automatically fixing errors and polishing language to sound like a native speaker. The tool is under heavy development with more features on the horizon.

github

: 118

refact-lsp

Refact Agent is a small executable written in Rust as part of the Refact Agent project. It lives inside your IDE to keep AST and VecDB indexes up to date, supporting connection graphs between definitions and usages in popular programming languages. It functions as an LSP server, offering code completion, chat functionality, and integration with various tools like browsers, databases, and debuggers. Users can interact with it through a Text UI in the command line.

github

: 57

air

Air is a new web framework for Python web development, built with FastAPI, Starlette, and Pydantic. It provides intuitive shortcuts and optimizations to expedite coding HTML with FastAPI, easy HTML content generation using Python classes, and seamless integration with Jinja templates. Air also offers utilities for using HTMX, HTML form validation powered by pydantic, and well-documented features. It aims to combine sophisticated HTML pages and a REST API into one app, making it easy to use FastAPI and Air together.

github

: 813

nyxtext

Nyxtext is a text editor built using Python, featuring Custom Tkinter with the Catppuccin color scheme and glassmorphic design. It follows a modular approach with each element organized into separate files for clarity and maintainability. NyxText is not just a text editor but also an AI-powered desktop application for creatives, developers, and students.

github

: 64

lingoose

LinGoose is a modular Go framework designed for building AI/LLM applications. It offers the flexibility to import only the necessary modules, abstracts features for customization, and provides a comprehensive solution for developing AI/LLM applications from scratch. The framework simplifies the process of creating intelligent applications by allowing users to choose preferred implementations or create their own. LinGoose empowers developers to leverage its capabilities to streamline the development of cutting-edge AI and LLM projects.

github

: 725

allchat

ALLCHAT is a Node.js backend and React MUI frontend for an application that interacts with the Gemini Pro 1.5 (and others), with history, image generating/recognition, PDF/Word/Excel upload, code run, model function calls and markdown support. It is a comprehensive tool that allows users to connect models to the world with Web Tools, run locally, deploy using Docker, configure Nginx, and monitor the application using a dockerized monitoring solution (Loki+Grafana).

github

: 147

AutoAgent

AutoAgent is a fully-automated and zero-code framework that enables users to create and deploy LLM agents through natural language alone. It is a top performer on the GAIA Benchmark, equipped with a native self-managing vector database, and allows for easy creation of tools, agents, and workflows without any coding. AutoAgent seamlessly integrates with a wide range of LLMs and supports both function-calling and ReAct interaction modes. It is designed to be dynamic, extensible, customized, and lightweight, serving as a personal AI assistant.

github

: 1.9k

crawl4ai

Crawl4AI is a powerful and free web crawling service that extracts valuable data from websites and provides LLM-friendly output formats. It supports crawling multiple URLs simultaneously, replaces media tags with ALT, and is completely free to use and open-source. Users can integrate Crawl4AI into Python projects as a library or run it as a standalone local server. The tool allows users to crawl and extract data from specified URLs using different providers and models, with options to include raw HTML content, force fresh crawls, and extract meaningful text blocks. Configuration settings can be adjusted in the `crawler/config.py` file to customize providers, API keys, chunk processing, and word thresholds. Contributions to Crawl4AI are welcome from the open-source community to enhance its value for AI enthusiasts and developers.

github

: 37.5k

ragflow

RAGFlow is an open-source Retrieval-Augmented Generation (RAG) engine that combines deep document understanding with Large Language Models (LLMs) to provide accurate question-answering capabilities. It offers a streamlined RAG workflow for businesses of all sizes, enabling them to extract knowledge from unstructured data in various formats, including Word documents, slides, Excel files, images, and more. RAGFlow's key features include deep document understanding, template-based chunking, grounded citations with reduced hallucinations, compatibility with heterogeneous data sources, and an automated and effortless RAG workflow. It supports multiple recall paired with fused re-ranking, configurable LLMs and embedding models, and intuitive APIs for seamless integration with business applications.

github

: 73.0k

liboai

liboai is a simple C++17 library for the OpenAI API, providing developers with access to OpenAI endpoints through a collection of methods and classes. It serves as a spiritual port of OpenAI's Python library, 'openai', with similar structure and features. The library supports various functionalities such as ChatGPT, Audio, Azure, Functions, Image DALL·E, Models, Completions, Edit, Embeddings, Files, Fine-tunes, Moderation, and Asynchronous Support. Users can easily integrate the library into their C++ projects to interact with OpenAI services.

github

: 321

Sunshine-AIO

Sunshine-AIO is an all-in-one step-by-step guide to set up Sunshine with all necessary tools for Windows users. It provides a dedicated display for game streaming, virtual monitor switching, automatic resolution adjustment, resource-saving features, game launcher integration, and stream management. The project aims to evolve into an AIO tool as it progresses, welcoming contributions from users.

github

: 54

aimeos-laravel

Aimeos Laravel is a professional, full-featured, and ultra-fast Laravel ecommerce package that can be easily integrated into existing Laravel applications. It offers a wide range of features including multi-vendor, multi-channel, and multi-warehouse support, fast performance, support for various product types, subscriptions with recurring payments, multiple payment gateways, full RTL support, flexible pricing options, admin backend, REST and GraphQL APIs, modular structure, SEO optimization, multi-language support, AI-based text translation, mobile optimization, and high-quality source code. The package is highly configurable and extensible, making it suitable for e-commerce SaaS solutions, marketplaces, and online shops with millions of vendors.

github

: 7.6k

mini-swe-agent

The mini-swe-agent is a lightweight AI agent designed to solve GitHub issues and more. It is a minimal tool with just 100 lines of Python code, suitable for researchers, developers, and engineers looking for a simple, powerful, and deployable solution. The agent is built to be convenient, deployable in various environments, and tested for performance. It focuses on providing a hackable tool that is simple, convenient, and flexible, without unnecessary bloat or complexity. Users can run the agent with any model using bash, making it ideal for benchmarking, fine-tuning, and reinforcement learning tasks.

github

: 1.7k

For similar tasks

fount

github

: 874

ZcChat

ZcChat is an AI desktop pet suitable for Galgame characters, featuring long-term memory, expressive actions, control over the computer, and voice functions. It utilizes Letta for AI long-term memory, Galgame-style character illustrations for more actions and expressions, and voice interaction with support for various voice synthesis tools like Vits. Users can configure characters, install Letta, set up voice synthesis and input, and control the pet to interact with the computer. The tool enhances visual and auditory experiences for users interested in AI desktop pets.

github

: 420

Facial-Data-Extractor

Facial Data Extractor is a software designed to extract facial data from images using AI, specifically to assist in character customization for Illusion series games. Currently, it only supports AI Shoujo and Honey Select2. Users can open images, select character card templates, extract facial data, and apply it to character cards in the game. The tool provides measurements for various facial features and allows for some customization, although perfect replication of faces may require manual adjustments.

github

: 81

GMTalker

GMTalker is an interactive digital human rendered by Unreal Engine, developed by the Media Intelligence Team at Bright Laboratory. The system integrates speech recognition, speech synthesis, natural language understanding, and lip-sync animation driving. It supports rapid deployment on Windows with only 2GB of VRAM required. The project showcases two 3D cartoon digital human avatars suitable for presentations, expansions, and commercial integration.

github

: 385

For similar jobs

sweep

Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.

github

: 7.1k

teams-ai

The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.

github

: 502

ai-guide

This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.

github

: 159

classifai

Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.

github

: 697

chatbot-ui

Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.

github

: 27.7k

BricksLLM

BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students

github

: 953

uAgents

uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.

github

: 1.3k

griptape

Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.

github

: 2.2k