fount
fount (aka 豊人（ほうと）/纺铽（fǎng tè | ㄈㄤˇ ㄊㄜˋ）) is an extensible framework for building and hosting AI character interactions. Built with pure JS, offers unparalleled flexibility via modular components, custom AI source integration, powerful plugins, and a seamless cross-platform chat experience.
Stars: 837
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:
Your Immersive AI Character Companion
Wanna know about the repo architecture? Check out DeepWiki!
Have you ever yearned for a journey alongside a character sprung from the pages of your imagination, a companion woven from the threads of dreams?
Or perhaps you've envisioned a digital confidant, an AI assistant as intuitive as the most advanced creations, effortlessly orchestrating your digital world?
Or maybe, just maybe, you've sought a connection beyond the ordinary, a realm where reality's edges blur, and an intimate, unfiltered understanding unfolds?
With nearly 
Lost characters, forgotten stories? Our vibrant and welcoming community awaits—a haven where kindred spirits gather, where developers and creators alike share their wisdom and creations.
A Glimpse into the World of fount
| Screenshots |
|---|
| Homepage |
| Theme Selection |
| Chat |
fount is a bridge, connecting you to the characters of your imagination, allowing you to effortlessly converse with them, craft your own, and share them with the world. It is a path made surprisingly accessible.
It is a wellspring (fount), where AI sources, characters, personas, worlds, and plugins flow together, allowing you to create and experience unique and compelling interactions.
fount is built for the future, ready to embrace new features born from its vibrant community. If you have a vision, a spark of an idea that belongs within fount's realm, we welcome your contribution.
-
Seamless Conversations, Anywhere A whisper started on your computer can be seamlessly continued on your phone or tablet. fount keeps your conversations synchronized, connecting you to your characters wherever you go.
-
Expressive, Immersive Chats fount embraces the full power of HTML, allowing characters to express themselves with rich text, images, and even interactive elements, making every conversation vivid and profound.
-
Gatherings of Minds: Native Group Chats Invite multiple characters into a single conversation and witness their dynamic and engaging interactions, creating stories that are uniquely yours.
-
A Beautiful, Customizable Interface Choose from over 30 stunning themes, or create your own. fount is your personal canvas.
-
Works Everywhere You Do fount runs seamlessly on Windows, macOS, Linux, and even Android, adapting to your needs through direct installation or the flexibility of Docker.
-
(For Advanced Users) Unshackled AI Source Integration: Embrace the Boundless fount offers unparalleled choice and flexibility in connecting to AI sources. Custom JavaScript code within the AI source generator allows you to connect to any AI source—OpenAI, Claude, OpenRouter, NovelAI, the Horde, Ooba, Tabby, Mistral, and more. Craft intricate regular expressions, call upon vast API libraries, and embed multimedia assets, all within the flow of your code. fount also natively supports creating API pools for intelligent request routing. The logic of communication bends to your will, shaped by the power of code.
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.
-
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.
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 realized 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 customize, 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).
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.
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 customized 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.
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.
# 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"-
Direct and Uncomplicated (Recommended): Download the
exefile 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
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 pull ghcr.io/steve02081504/fountfount removeShould 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.
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.
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.
[](https://github.com/topics/fount-repo)[](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.
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
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
anchorpositioning 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.
- Lacking support for
-
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.
- Also lacking support for
-
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.
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 tasksFor Jobs:
Alternative AI tools for fount
Similar Open Source Tools
fount
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.
tinystruct
Tinystruct is a simple Java framework designed for easy development with better performance. It offers a modern approach with features like CLI and web integration, built-in lightweight HTTP server, minimal configuration philosophy, annotation-based routing, and performance-first architecture. Developers can focus on real business logic without dealing with unnecessary complexities, making it transparent, predictable, and extensible.
mlflow
MLflow is a platform to streamline machine learning development, including tracking experiments, packaging code into reproducible runs, and sharing and deploying models. MLflow offers a set of lightweight APIs that can be used with any existing machine learning application or library (TensorFlow, PyTorch, XGBoost, etc), wherever you currently run ML code (e.g. in notebooks, standalone applications or the cloud). MLflow's current components are:
* `MLflow Tracking
bee-agent-framework
The Bee Agent Framework is an open-source tool for building, deploying, and serving powerful agentic workflows at scale. It provides AI agents, tools for creating workflows in Javascript/Python, a code interpreter, memory optimization strategies, serialization for pausing/resuming workflows, traceability features, production-level control, and upcoming features like model-agnostic support and a chat UI. The framework offers various modules for agents, llms, memory, tools, caching, errors, adapters, logging, serialization, and more, with a roadmap including MLFlow integration, JSON support, structured outputs, chat client, base agent improvements, guardrails, and evaluation.
node-llama-cpp
node-llama-cpp is a tool that allows users to run AI models locally on their machines. It provides pre-built bindings with the option to build from source using cmake. Users can interact with text generation models, chat with models using a chat wrapper, and force models to generate output in a parseable format like JSON. The tool supports Metal and CUDA, offers CLI functionality for chatting with models without coding, and ensures up-to-date compatibility with the latest version of llama.cpp. Installation includes pre-built binaries for macOS, Linux, and Windows, with the option to build from source if binaries are not available for the platform.
incubator-kie-optaplanner
A fast, easy-to-use, open source AI constraint solver for software developers. OptaPlanner is a powerful tool that helps developers solve complex optimization problems by providing a constraint satisfaction solver. It allows users to model and solve planning and scheduling problems efficiently, improving decision-making processes and resource allocation. With OptaPlanner, developers can easily integrate optimization capabilities into their applications, leading to better performance and cost-effectiveness.
aigne-framework
AIGNE Framework is a functional AI application development framework designed to simplify and accelerate the process of building modern applications. It combines functional programming features, powerful artificial intelligence capabilities, and modular design principles to help developers easily create scalable solutions. With key features like modular design, TypeScript support, multiple AI model support, flexible workflow patterns, MCP protocol integration, code execution capabilities, and Blocklet ecosystem integration, AIGNE Framework offers a comprehensive solution for developers. The framework provides various workflow patterns such as Workflow Router, Workflow Sequential, Workflow Concurrency, Workflow Handoff, Workflow Reflection, Workflow Orchestration, Workflow Code Execution, and Workflow Group Chat to address different application scenarios efficiently. It also includes built-in MCP support for running MCP servers and integrating with external MCP servers, along with packages for core functionality, agent library, CLI, and various models like OpenAI, Gemini, Claude, and Nova.
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.
moai
moai is a PyTorch-based AI Model Development Kit (MDK) designed to improve data-driven model workflows, design, and understanding. It offers modularity via monads for model building blocks, reproducibility via configuration-based design, productivity via a data-driven domain modelling language (DML), extensibility via plugins, and understanding via inter-model performance and design aggregation. The tool provides specific integrated actions like play, train, evaluate, plot, diff, and reprod to support heavy data-driven workflows with analytics, knowledge extraction, and reproduction. moai relies on PyTorch, Lightning, Hydra, TorchServe, ONNX, Visdom, HiPlot, Kornia, Albumentations, and the wider open-source community for its functionalities.
unify
The Unify Python Package provides access to the Unify REST API, allowing users to query Large Language Models (LLMs) from any Python 3.7.1+ application. It includes Synchronous and Asynchronous clients with Streaming responses support. Users can easily use any endpoint with a single key, route to the best endpoint for optimal throughput, cost, or latency, and customize prompts to interact with the models. The package also supports dynamic routing to automatically direct requests to the top-performing provider. Additionally, users can enable streaming responses and interact with the models asynchronously for handling multiple user requests simultaneously.
sec-parser
The `sec-parser` project simplifies extracting meaningful information from SEC EDGAR HTML documents by organizing them into semantic elements and a tree structure. It helps in parsing SEC filings for financial and regulatory analysis, analytics and data science, AI and machine learning, causal AI, and large language models. The tool is especially beneficial for AI, ML, and LLM applications by streamlining data pre-processing and feature extraction.
lanarky
Lanarky is a Python web framework designed for building microservices using Large Language Models (LLMs). It is LLM-first, fast, modern, supports streaming over HTTP and WebSockets, and is open-source. The framework provides an abstraction layer for developers to easily create LLM microservices. Lanarky guarantees zero vendor lock-in and is free to use. It is built on top of FastAPI and offers features familiar to FastAPI users. The project is now in maintenance mode, with no active development planned, but community contributions are encouraged.
Kori
Kori is a unified note-taking app with AI capabilities, providing a consistent experience across Android, iOS, Windows, macOS, and Linux. It supports various formats like Drawing, Markdown, TXT, LaTeX, Mermaid diagrams, and Todo.txt lists. Users can benefit from AI co-writing features, note outline generation, find and replace, note templates, local media support, and export options. The app follows Material Design 3 guidelines, offers comprehensive mouse and keyboard support, and is optimized for different screen sizes and orientations.
scalene
Scalene is a high-performance CPU, GPU, and memory profiler for Python that provides detailed information and runs faster than many other profilers. It incorporates AI-powered proposed optimizations, allowing users to generate optimization suggestions by clicking on specific lines or regions of code. Scalene separates time spent in Python from native code, highlights hotspots, and identifies memory usage per line. It supports GPU profiling on NVIDIA-based systems and detects memory leaks. Users can generate reduced profiles, profile specific functions using decorators, and suspend/resume profiling for background processes. Scalene is available as a pip or conda package and works on various platforms. It offers features like profiling at the line level, memory trends, copy volume reporting, and leak detection.
clearml
ClearML is a suite of tools designed to streamline the machine learning workflow. It includes an experiment manager, MLOps/LLMOps, data management, and model serving capabilities. ClearML is open-source and offers a free tier hosting option. It supports various ML/DL frameworks and integrates with Jupyter Notebook and PyCharm. ClearML provides extensive logging capabilities, including source control info, execution environment, hyper-parameters, and experiment outputs. It also offers automation features, such as remote job execution and pipeline creation. ClearML is designed to be easy to integrate, requiring only two lines of code to add to existing scripts. It aims to improve collaboration, visibility, and data transparency within ML teams.
clearml
ClearML is an auto-magical suite of tools designed to streamline AI workflows. It includes modules for experiment management, MLOps/LLMOps, data management, model serving, and more. ClearML offers features like experiment tracking, model serving, orchestration, and automation. It supports various ML/DL frameworks and integrates with Jupyter Notebook and PyCharm for remote debugging. ClearML aims to simplify collaboration, automate processes, and enhance visibility in AI projects.
For similar tasks
fount
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.