ComfyUI-mnemic-nodes
Nodes: Get File Path, Save Text File, Download Image from URL, Tiktoken Tokenizer, String Cleaning, Groq LLM, VLM, ALM API
Stars: 53
ComfyUI-mnemic-nodes is a repository hosting a collection of nodes developed for ComfyUI, providing useful components to enhance project functionality. The nodes include features like returning file paths, saving text files, downloading images from URLs, tokenizing text, cleaning strings, querying Groq language models, generating negative prompts, and more. Some nodes are experimental and marked with a 'Caution' label. Installation instructions and setup details are provided for each node, along with examples and presets for different tasks.
README:
This repository hosts a collection of nodes developed for ComfyUI. It aims to share useful components that enhance the functionality of ComfyUI projects. Some nodes are forks or versions of nodes from other packs, some are bespoke and useful, and some are experimental and are quite useless, so they have been marked with a Caution label in this document.
📁 Get File Path - Returns the file path in different formats to a file in your /input-folder.
💾 Save Text File With Path Node - Save text file, and return the saved file's path.
🖼️ Download Image from URL Node - Download an image from the web.
🔠 Tiktoken Tokenizer Info - Returns token information about input text and lets you split it.
🧹 String Cleaning - Cleans up text strings.
✨💬 Groq LLM API Node - Query Groq large language model.
✨📷 Groq VLM API Node - Query Groq vision language model.
✨📝 Groq ALM API Node - Query Groq Audio Model.
⛔ Generate Negative Prompt Node - Generate negative prompts automatically.
You may need to manually install the requirements. They should be listed in requirements.txt
You may need to install the following libraries using pip install XXX:
configparser
groq
transformers
torch
This node returns the file path of a given file in the \input-folder.
It is meant to have a browse-button so you can browse to any file, but it doesn't yet.
If you know how to add this, please let me know or do a pull request.
This node is adapted and enhanced from the Save Text File node found in the YMC GitHub ymc-node-suite-comfyui pack.
The node can now give you a full file path output if you need it, as well as output the file-name as a separate output, in case you need it for something else.
[!IMPORTANT]
The node was severely updated so existing workflows are going to break. I won't do another overhaul like this.
The new node is more consistent in functionality and more intentional with the inputs and outputs.
It now handles more edge cases and supports both a prefix, suffix, a dynamic counting with customizable separator before/after the counter in the right circumstances.
Sorry for any troubles caused.
This node downloads an image from an URL and lets you use it.
It also outputs the Width/Height of the image.
- By default, it will save the image to the /input directory.
- Clear the
save_pathline to prevent saving the image (it will still be saved in the TEMP-folder).
- Clear the
- If you enter a name in the
save_file_name_overridesection, the file will be saved with this name.- You can enter or ignore the file extension.
- If you enter one, it will rename the file to the chosen extension without converting the image.
- Supported image formats: JPG, JPEG, PNG, WEBP.
- Does not support saving with transparency.
[!IMPORTANT]
This node was renamed in the code to match the functionality. This may break existing nodes.
This node takes text as input, and returns a bunch of data from the tiktoken tokenizer.
It returns the following values:
-
token_count: Total number of tokens -
character_count: Total number of characters -
word_count: Total number of words -
split_string: Tokenized list of strings -
split_string_list: Tokenized list of strings (output as list) -
split_token_ids: List of token IDs -
split_token_ids_list: List of token IDs (output as list) -
text_hash: Text hash -
special_tokens_used: Special tokens used -
special_tokens_used_list: Special tokens used (output as list) -
token_chunk_by_size: Returns the input text, split into different strings in a list by thetoken_chunk_sizevalue. -
token_chunk_by_size_to_word: Same as above but respects "words" by stripping backwards to the nearest space and splitting the chunk there. -
token_chunk_by_size_to_section: Same as above, but strips backwards to the nearest newline, period or comma.
This node helps you quickly clean up and format strings by letting you remove leading or trailing spaces, periods, commas, or custom text, as well as removing linebreaks, or replacing them with a period.
-
input_string: Your input string. Use ComfyUI-Easy-Use for looping through a list of strings. -
collapse_sequential_spaces: Collapses sequential spaces (" ") in a string into one. -
strip_leading_spaces: Removes any leading spaces from each line of the input string. -
strip_trailing_spaces: Removes any trailing spaces from each line of the input string. -
strip_leading_symbols: Removes leading punctuation symbols (, . ! ? : ;) from each line of the input string. -
strip_trailing_symbols: Removes leading punctuation symbols (, . ! ? : ;) from each line of the input string. -
strip_inside_tags: Removes any tags and the characters inside. <> would strip out anything like<html>or</div>, including the<and> -
strip_newlines: Removes any linebreaks in the input string. -
replace_newlines_with_period_space: Replaces any linebreaks in the input string with a ". ". If multiple linebreaks are found in a row, they will be replaced with a single ". ". -
strip_leading_custom: Removes any leading characters, words or symbols from each line of the input string. One entry per line. Space (" ") is supported. Will be processed in order, so you can combine multiple lines. Does not support linebreak removal. -
strip_trailing_custom: Removes any trailing characters, words or symbols from each line of the input string. One entry per line. Space (" ") is supported. Will be processed in order, so you can combine multiple lines. Does not support linebreak removal. -
strip_all_custom: Removes any characters, words or symbols found anywhere in the text. One entry per line. Space (" ") is supported. Will be processed in order, so you can combine multiple lines. Does not support linebreak removal. -
multiline_find: Find and replace for multiple entries. Will be processed in order. -
multiline_replace: Find and replace for multiple entries. Will be processed in order.
[!IMPORTANT]
This node was renamed to match the new VLM and ALM nodes added.
This node makes an API call to groq, and returns the response in text format.
You need to manually enter your groq API key into the GroqConfig.ini file.
Currently, the Groq API can be used for free, with very friendly and generous rate limits.
model: Choose from a drop-down one of the available models. The list need to be manually updated when they add additional models.
preset: This is a dropdown with a few preset prompts, the user's own presets, or the option to use a fully custom prompt. See examples and presets below.
system_message: The system message to send to the API. This is only used with the Use [system_message] and [user_input] option in the preset list. The other presets provide their own system message.
user_input: This is used with the Use [system_message] and [user_input], but can also be used with presets. In the system message, just mention the USER to refer to this input field. See the presets for examples.
temperature: Controls the randomness of the response. A higher temperature leads to more varied responses.
max_tokens: The maximum number of tokens that the model can process in a single response. Limits can be found here.
top_p: The threshold for the most probable next token to use. Higher values result in more predictable results.
seed: Random seed. Change the control_after_generate option below if you want to re-use the seed or get a new generation each time.
control_after_generate: Standard comfy seed controls. Set it to fixed or randomize based on your needs.
stop: Enter a word or stopping sequence which will terminate the AI's output. The string itself will not be returned.
- Note:
stopis not compatible withjson_mode.
json_mode: If enabled, the model will output the result in JSON format.
-
Note: You must include a description of the desired JSON format in the system message. See the examples below.
-
Note:
json_modeis not compatible withstop.
The following presets can be found in the \nodes\groq\DefaultPrompts.json file. They can be edited, but it's better to copy the presets to the UserPrompts.json-file.
This preset, (default), means that the next two fields are fully utilized. Manually enter the instruction to the AI in the system_message field, and if you have any specific requests in the user_input field. Combined they make up the complete instruction to the LLM. Sometimes a system message is enough, and inside the system message you could even refer to the contents of the user input.
This is a tailored instruction that will return a randomized Stable Diffusion-like prompt. If you enter some text in the user_input area, you should get a prompt about this subject. You can also leave it empty and it will create its own examples based on the underlying prompt.
You should get better result from providing it with a short sentence to start it off.
This will return a negative prompt which intends to be used together with the user_input string to complement it and enhance a resulting image.
This will return a list format of 10 subjects for an image, described in a simple and short style. These work good as user_input for the Generate a prompt about [user_input] preset.
You should also manually turn on json_mode when using this prompt. You should get a stable json formatted output from it in a similar style to the Generate a prompt about [user_input] above.
Note: You can actually use the entire result (JSON and all), as your prompt. Stable Diffusion seem to handle it quite fine.
Edit the \nodes\groq\UserPrompts.json file to create your own presets.
Follow the existing structure and look at the DefaultPrompts.json for examples.
[!IMPORTANT]
Added new Llama 3.2 vision model to the list, but this model is not yet officially available. Once it is, this should automatically work.
This node makes an API call to groq with an attached image and then uses Vision Language Models to return a description of the image, or answer to a question about the image in text format.
You need to manually enter your groq API key into the GroqConfig.ini file.
Currently, the Groq API can be used for free, with very friendly and generous rate limits.
Image Size Limit: The maximum allowed size for a request containing an image URL as input is 20MB. Requests larger than this limit will return a 400 error.
Request Size Limit (Base64 Enconded Images): The maximum allowed size for a request containing a base64 encoded image is 4MB. Requests larger than this limit will return a 413 error.
This node makes an API call to groq with an attached audio file and then uses Audio Language Models to transcribe the audio and return the text in different output formats.
The model distil-whisper-large-v3-en only supports the language en.
The model whisper-large-v3 supports the languages listed below. It can also be left empty, but this provides worse results than running the model locally.
[!NOTE] The presets / prompt do very little. They are meant to help you guide the output, but I don't get any relevant results.
You can convert the file_path to input to use the Get File Path node to find your files.
https://www.wikiwand.com/en/articles/List_of_ISO_639_language_codes
is tg uz zh ru tr hi la tk haw fr vi cs hu kk he cy bs sw ht mn gl si mg sa es ja pt lt mr fa sl kn uk ms ta hr bg pa yi fo th lv ln ca br sq jv sn gu ba te bn et sd tl ha de hy so oc nn az km yo ko pl da mi ml ka am tt su yue nl no ne mt my ur ps ar id fi el ro as en it sk be lo lb bo sv sr mk eu
You need to manually enter your groq API key into the GroqConfig.ini file.
Currently, the Groq API can be used for free, with very friendly and generous rate limits.
You can use this to generate files to use in a Karaoke app.
[!CAUTION] This node is highly experimental, and does not produce any useful result right now. It also requires you to download a specially trained model for it. It's just not worth the effort. It's mostly here to share a work in progress project.
This node utilizes a GPT-2 text inference model to generate a negative prompt that is supposed to enhance the aspects of the positive prompt.
[!IMPORTANT] Installation Step: Download the weights.pt file from the project's Hugging Face repository.
Place the
weights.ptfile in the following directory of your ComfyUI setup without renaming it:\ComfyUI\custom_nodes\ComfyUI-mnemic-nodes\nodes\negativepromptThe directory should resemble the following structure:
For additional information, please visit the project's GitHub page.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for ComfyUI-mnemic-nodes
Similar Open Source Tools
ComfyUI-mnemic-nodes
ComfyUI-mnemic-nodes is a repository hosting a collection of nodes developed for ComfyUI, providing useful components to enhance project functionality. The nodes include features like returning file paths, saving text files, downloading images from URLs, tokenizing text, cleaning strings, querying Groq language models, generating negative prompts, and more. Some nodes are experimental and marked with a 'Caution' label. Installation instructions and setup details are provided for each node, along with examples and presets for different tasks.
bedrock-claude-chat
This repository is a sample chatbot using the Anthropic company's LLM Claude, one of the foundational models provided by Amazon Bedrock for generative AI. It allows users to have basic conversations with the chatbot, personalize it with their own instructions and external knowledge, and analyze usage for each user/bot on the administrator dashboard. The chatbot supports various languages, including English, Japanese, Korean, Chinese, French, German, and Spanish. Deployment is straightforward and can be done via the command line or by using AWS CDK. The architecture is built on AWS managed services, eliminating the need for infrastructure management and ensuring scalability, reliability, and security.
UltraSinger
UltraSinger is a tool under development that automatically creates UltraStar.txt, midi, and notes from music. It pitches UltraStar files, adds text and tapping, creates separate UltraStar karaoke files, re-pitches current UltraStar files, and calculates in-game score. It uses multiple AI models to extract text from voice and determine pitch. Users should mention UltraSinger in UltraStar.txt files and only use it on Creative Commons licensed songs.
metavoice-src
MetaVoice-1B is a 1.2B parameter base model trained on 100K hours of speech for TTS (text-to-speech). It has been built with the following priorities: * Emotional speech rhythm and tone in English. * Zero-shot cloning for American & British voices, with 30s reference audio. * Support for (cross-lingual) voice cloning with finetuning. * We have had success with as little as 1 minute training data for Indian speakers. * Synthesis of arbitrary length text
patchwork
PatchWork is an open-source framework designed for automating development tasks using large language models. It enables users to automate workflows such as PR reviews, bug fixing, security patching, and more through a self-hosted CLI agent and preferred LLMs. The framework consists of reusable atomic actions called Steps, customizable LLM prompts known as Prompt Templates, and LLM-assisted automations called Patchflows. Users can run Patchflows locally in their CLI/IDE or as part of CI/CD pipelines. PatchWork offers predefined patchflows like AutoFix, PRReview, GenerateREADME, DependencyUpgrade, and ResolveIssue, with the flexibility to create custom patchflows. Prompt templates are used to pass queries to LLMs and can be customized. Contributions to new patchflows, steps, and the core framework are encouraged, with chat assistants available to aid in the process. The roadmap includes expanding the patchflow library, introducing a debugger and validation module, supporting large-scale code embeddings, parallelization, fine-tuned models, and an open-source GUI. PatchWork is licensed under AGPL-3.0 terms, while custom patchflows and steps can be shared using the Apache-2.0 licensed patchwork template repository.
gpt-engineer
GPT-Engineer is a tool that allows you to specify a software in natural language, sit back and watch as an AI writes and executes the code, and ask the AI to implement improvements.
OpenAI-sublime-text
The OpenAI Completion plugin for Sublime Text provides first-class code assistant support within the editor. It utilizes LLM models to manipulate code, engage in chat mode, and perform various tasks. The plugin supports OpenAI, llama.cpp, and ollama models, allowing users to customize their AI assistant experience. It offers separated chat histories and assistant settings for different projects, enabling context-specific interactions. Additionally, the plugin supports Markdown syntax with code language syntax highlighting, server-side streaming for faster response times, and proxy support for secure connections. Users can configure the plugin's settings to set their OpenAI API key, adjust assistant modes, and manage chat history. Overall, the OpenAI Completion plugin enhances the Sublime Text editor with powerful AI capabilities, streamlining coding workflows and fostering collaboration with AI assistants.
torchchat
torchchat is a codebase showcasing the ability to run large language models (LLMs) seamlessly. It allows running LLMs using Python in various environments such as desktop, server, iOS, and Android. The tool supports running models via PyTorch, chatting, generating text, running chat in the browser, and running models on desktop/server without Python. It also provides features like AOT Inductor for faster execution, running in C++ using the runner, and deploying and running on iOS and Android. The tool supports popular hardware and OS including Linux, Mac OS, Android, and iOS, with various data types and execution modes available.
reader
Reader is a tool that converts any URL to an LLM-friendly input with a simple prefix `https://r.jina.ai/`. It improves the output for your agent and RAG systems at no cost. Reader supports image reading, captioning all images at the specified URL and adding `Image [idx]: [caption]` as an alt tag. This enables downstream LLMs to interact with the images in reasoning, summarizing, etc. Reader offers a streaming mode, useful when the standard mode provides an incomplete result. In streaming mode, Reader waits a bit longer until the page is fully rendered, providing more complete information. Reader also supports a JSON mode, which contains three fields: `url`, `title`, and `content`. Reader is backed by Jina AI and licensed under Apache-2.0.
tonic_validate
Tonic Validate is a framework for the evaluation of LLM outputs, such as Retrieval Augmented Generation (RAG) pipelines. Validate makes it easy to evaluate, track, and monitor your LLM and RAG applications. Validate allows you to evaluate your LLM outputs through the use of our provided metrics which measure everything from answer correctness to LLM hallucination. Additionally, Validate has an optional UI to visualize your evaluation results for easy tracking and monitoring.
baml
BAML is a config file format for declaring LLM functions that you can then use in TypeScript or Python. With BAML you can Classify or Extract any structured data using Anthropic, OpenAI or local models (using Ollama) ## Resources  [Discord Community](https://discord.gg/boundaryml)  [Follow us on Twitter](https://twitter.com/boundaryml) * Discord Office Hours - Come ask us anything! We hold office hours most days (9am - 12pm PST). * Documentation - Learn BAML * Documentation - BAML Syntax Reference * Documentation - Prompt engineering tips * Boundary Studio - Observability and more #### Starter projects * BAML + NextJS 14 * BAML + FastAPI + Streaming ## Motivation Calling LLMs in your code is frustrating: * your code uses types everywhere: classes, enums, and arrays * but LLMs speak English, not types BAML makes calling LLMs easy by taking a type-first approach that lives fully in your codebase: 1. Define what your LLM output type is in a .baml file, with rich syntax to describe any field (even enum values) 2. Declare your prompt in the .baml config using those types 3. Add additional LLM config like retries or redundancy 4. Transpile the .baml files to a callable Python or TS function with a type-safe interface. (VSCode extension does this for you automatically). We were inspired by similar patterns for type safety: protobuf and OpenAPI for RPCs, Prisma and SQLAlchemy for databases. BAML guarantees type safety for LLMs and comes with tools to give you a great developer experience:  Jump to BAML code or how Flexible Parsing works without additional LLM calls. | BAML Tooling | Capabilities | | ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | BAML Compiler install | Transpiles BAML code to a native Python / Typescript library (you only need it for development, never for releases) Works on Mac, Windows, Linux  | | VSCode Extension install | Syntax highlighting for BAML files Real-time prompt preview Testing UI | | Boundary Studio open (not open source) | Type-safe observability Labeling |
transcriptionstream
Transcription Stream is a self-hosted diarization service that works offline, allowing users to easily transcribe and summarize audio files. It includes a web interface for file management, Ollama for complex operations on transcriptions, and Meilisearch for fast full-text search. Users can upload files via SSH or web interface, with output stored in named folders. The tool requires a NVIDIA GPU and provides various scripts for installation and running. Ports for SSH, HTTP, Ollama, and Meilisearch are specified, along with access details for SSH server and web interface. Customization options and troubleshooting tips are provided in the documentation.
linkedin-api
The Linkedin API for Python allows users to programmatically search profiles, send messages, and find jobs using a regular Linkedin user account. It does not require 'official' API access, just a valid Linkedin account. However, it is important to note that this library is not officially supported by LinkedIn and using it may violate LinkedIn's Terms of Service. Users can authenticate using any Linkedin account credentials and access features like getting profiles, profile contact info, and connections. The library also provides commercial alternatives for extracting data, scraping public profiles, and accessing a full LinkedIn API. It is not endorsed or supported by LinkedIn and is intended for educational purposes and personal use only.
telemetry-airflow
This repository codifies the Airflow cluster that is deployed at workflow.telemetry.mozilla.org (behind SSO) and commonly referred to as "WTMO" or simply "Airflow". Some links relevant to users and developers of WTMO: * The `dags` directory in this repository contains some custom DAG definitions * Many of the DAGs registered with WTMO don't live in this repository, but are instead generated from ETL task definitions in bigquery-etl * The Data SRE team maintains a WTMO Developer Guide (behind SSO)
obsidian-bmo-chatbot
Obsidian BMO Chatbot is a plugin that allows users to generate and brainstorm ideas while creating notes using Large Language Models (LLMs) from various providers like Ollama, LM Studio, Anthropic, OpenAI, Mistral AI, and more. Users can interact with self-hosted LLMs, create chatbots with specific knowledge and personalities, chat from anywhere within Obsidian, and receive formatted responses in Obsidian Markdown. The plugin also offers features like customizable bot name, prompt selection, saving chat history as markdown, and more. Users can activate the plugin through Obsidian Community plugins or by installing it manually. Supported models include Ollama, LM Studio, Anthropic, Mistral AI, Google Gemini Pro, OpenAI, and Openrouter provided models.
robocorp
Robocorp is a platform that allows users to create, deploy, and operate Python automations and AI actions. It provides an easy way to extend the capabilities of AI agents, assistants, and copilots with custom actions written in Python. Users can create and deploy tools, skills, loaders, and plugins that securely connect any AI Assistant platform to their data and applications. The Robocorp Action Server makes Python scripts compatible with ChatGPT and LangChain by automatically creating and exposing an API based on function declaration, type hints, and docstrings. It simplifies the process of developing and deploying AI actions, enabling users to interact with AI frameworks effortlessly.
For similar tasks
ComfyUI-mnemic-nodes
ComfyUI-mnemic-nodes is a repository hosting a collection of nodes developed for ComfyUI, providing useful components to enhance project functionality. The nodes include features like returning file paths, saving text files, downloading images from URLs, tokenizing text, cleaning strings, querying Groq language models, generating negative prompts, and more. Some nodes are experimental and marked with a 'Caution' label. Installation instructions and setup details are provided for each node, along with examples and presets for different tasks.
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.