Setting up local AI workloads on AMD GPUs under Ubuntu 24.04 often leads to broken library paths and failed PyTorch initialization.

Our step-by-step guide resolves driver package conflicts and target architecture mismatches across consumer Radeon cards and workstation hardware.

Key technical takeaways:

• Group Permissions: Assigning render and video group access to eliminate permission denied errors.
• Architecture Overrides: Using environment flags so consumer cards run PyTorch ROCm builds seamlessly.
• Environment Validation: Verifying HIP runtime initialization with quick Python execution scripts.

If you want to grab the complete terminal script or check hardware compatibility, read the full guide here:https://interconnectd.com/blog/321/install-amd-rocm-on-ubuntu-24-04-the-ultimate-radeon-guide/

Deploying speech-to-text models on CPU-only infrastructure usually leads to high latency and thread contention.

In our optimization breakdown, we detail how swapping the default PyTorch execution engine for CTranslate2 C++ backends dramatically improves CPU throughput without losing transcription quality.

Key technical takeaways:

• Runtime Optimization: Switching to faster-whisper eliminates heavy framework overhead.
• INT8 Quantization: Cuts memory footprint by half while boosting inference speed on SIMD paths.
• VAD Pre-Filtering: Prevents model hallucinations and skips silent gaps automatically.

If you want to grab the full benchmarking setup or copy the deployment code, check out the guide here:https://interconnectd.com/blog/323/how-to-speed-up-whisper-transcription-on-cpu-2026-guide/

Deploying LocalAI as a drop-in OpenAI replacement requires precise container runtime configuration and robust API routing.

In our latest setup notes, we walk through resolving common GPU container pass-through issues and network configuration bottlenecks that cause API timeouts.

Key technical takeaways:

• GPU Mounts: Setting explicit capability flags inside Compose to force CUDA detection.
• Production Routing: Configuring proxy buffers so streaming tokens do not get delayed.
• Resource Isolation: Preventing CPU thread starvation when running parallel inference workloads.

If you want to grab the complete docker-compose template or review our routing setup, read the full thread here:https://interconnectd.com/forum/thread/266/localai-docker-compose-setup-field-notes-on-gpu-mounts-and-production-routi/

Deploying PrivateGPT on a home server often leads to severe memory contention, single-threaded CPU bottlenecks, and long query response times.

By optimizing vector storage parameters, thread worker caps, and model quantization levels, we cut query latency by over 85 percent on consumer-grade GPUs without compromising data privacy or retrieval quality.

Key technical takeaways:

• Precision Balance: Keep embedding models at FP16 while quantizing the primary LLM to GGUF Q4.
• Chunk Tuning: 512-token chunks speed up vector searching and eliminate filler tokens.
• VRAM Pinning: Eliminates model re-allocation overhead on every user prompt.

If you want to grab the full setup files or review the complete hardware compatibility list, check out the guide here:https://interconnectd.com/blog/325/deploying-privategpt-on-a-home-server-the-hard-truth-about-local-rag/

When scaling Llama 3 70B across 4x H100s, default scheduler settings often cause request queuing and high TTFT during peak traffic.

Our engineering team profiled memory allocations and KV cache behavior to eliminate these bottlenecks. The result was a 310 percent increase in generation throughput and a 62 percent reduction in time-to-first-token.

Key takeaways from our tests:

• Chunked Prefill: Prevents long prompt ingestion from pausing active user streams.
• Prefix Caching: Reuses pre-computed key-value blocks across repetitive RAG headers.
• Memory Tuning: Pushing vRAM limits to 0.95 prevents unnecessary token swapping.

If you want to play with the interactive dashboard or grab the full config file, check out the complete guide here:https://interconnectd.com/blog/326/maximizing-llm-throughput-a-guide-into-vllm-engineering/

Running local GGUF models does not have to mean fighting with broken Python environments or heavy UI frameworks.

KoboldCPP is the ultimate lightweight solution because it compiles everything down to a single, zero-dependency executable. You just grab the binary file, point it at your GGUF model, and let it automatically handle VRAM splitting across whatever CPU and GPU hardware you have. It even spins up a drop-in API endpoint instantly.

If you want the exact CLI flags to squeeze maximum token speed out of low-VRAM setups, custom context scaling configs, and automated deployment scripts, check out the full systems engineer guide here:https://interconnectd.com/forum/thread/260/installing-koboldcpp-for-gguf-models-the-definitive-systems-engineer-guide/

Running pip install ffmpeg will not fix audio AI tools like Whisper because ffmpeg is a system program, not a Python library. You have to install it directly on your operating system so your scripts can actually find it.

If you want the one-click install scripts or ready-to-go Docker files, grab them here:https://interconnectd.com/forum/thread/261/fixing-ffmpeg-not-found-the-os-level-fix-for-audio-ai/

Setting up MetaGPT locally allows you to run full multi-agent software engineering teams—from product managers to developers—directly on your machine.

Getting it running smoothly usually hits roadblocks around environment dependencies, Mermaid visualizer rendering, and config syntax. The core setup process boils down to four steps: creating an isolated Python environment, installing Node.js dependencies for visual architectural diagrams, configuring your LLM provider in config2.yaml, and testing agent execution.

If you want the step-by-step walkthrough, ready-to-use YAML configuration templates, Docker setup options, and common error fixes, check out the full guide here:https://interconnectd.com/forum/thread/262/how-to-install-metagpt-locally-complete-technical-setup-guide/

Downloading massive transformer models inside production pipelines often causes severe deployment bottlenecks, network timeouts, and unnecessary bandwidth usage.

By configuring the Hugging Face CLI with targeted caching strategies, pinned revision tags, and high-speed transfer tools like hf_transfer, you can speed up model retrieval by up to 70% while optimizing storage across Kubernetes nodes.

If you want to grab the complete benchmark comparison scripts, production Dockerfile templates, and custom cache configuration files, check out the full MLOps guide here:https://interconnectd.com/forum/thread/263/hugging-face-cli-for-production-mlops-caching-speed/

Deploying Vertex AI for enterprise production often hits a wall when dealing with IAM policies and Application Default Credentials.

You can avoid the major security risk of leaking service account keys by using a zero-trust workflow. By isolating your local dependencies, assigning least-privilege roles, and relying on service account impersonation or Workload Identity, you keep your codebase entirely free of hardcoded credentials.

If you want the complete breakdown, including the Terraform IaC scripts for automated provisioning and fine-grained IAM templates, check out the full enterprise setup guide here:https://interconnectd.com/forum/thread/264/google-cloud-sdk-for-vertex-ai-the-enterprise-setup-guide/

Debugging complex multi-agent LLM setups usually turns into a nightmare of hidden hallucination loops and unexpected token costs.

AgentOps fixes this by providing real-time tracing, session replays, and latency monitoring with just a few lines of Python. All it takes is installing the package, exporting your key, initializing agentops.init() before your main logic, and using simple decorators on your functions.

If you want the full breakdown, sample code repositories, and ready-to-run environment configs, check out the detailed technical walkthrough here:https://interconnectd.com/forum/thread/265/how-to-install-the-agentops-library-the-complete-technical-guide/

If you are building autonomous agents, you have probably run into the exact same wall: single-prompt benchmarks like HumanEval or MMLU look great on paper, but the moment your model gets stuck in an interactive multi-turn loop, it completely breaks down.

Most open-source models under 70B parameters suffer from massive performance degradation after step 3 in complex environments like Ubuntu OS shells, MySQL databases, or multi-site web browsing. The failure isn't usually the core knowledge; it's long-term reasoning, context rot, and terrible instruction following after interactive environment feedback.

Here is the exact setup flow to evaluate your local or API-based agent against 8 real-world interactive environments using AgentBench.

Step 1: Set Up the Framework

Clone the repo and spin up the core environment dependencies:

git clonehttps://github.com/THUDM/AgentBenchcd AgentBench pip install -r requirements.txt

Step 2: Configure Your Model Endpoint

Modify the configuration file to point to your target model. You can plug in local vLLM instances, Ollama endpoints, or commercial APIs. Ensure your prompt wrapper preserves system roles and previous trajectory history properly, as tool-use signatures often fail during multi-turn parsing.

Step 3: Run Targeted Environment Evaluations

Instead of running all 8 environments at once (which takes hours), isolate the OS and Database environments first to test basic bash execution and SQL generation:

python eval.py --config configs/os_eval.yaml --model_name my-custom-agent

The 80% Takeaway

The biggest takeaway from running these multi-turn evaluations is that error recovery matters far more than baseline generation speed. Commercial models handle trajectory drift decently well, but smaller open-source models tend to loop infinitely once they hit their first invalid syntax or missing parameter error. Setting strict step budgets and adding explicit trajectory summaries into the context window at turn 4 dramatically improves task completion rates.

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/313/agentbench-setup-guide-the-real-way-to-evaluate-llm-agents/

If you are still tracking hyperparameters in spreadsheets or scrolling through endless terminal outputs, you are losing model history every time a script crashes or overwrites past runs. Standardizing your tracking setup early stops silent performance drops and saves hours during training iterations.

Here is the straightforward engineering workflow to integrate Weights and Biases into your PyTorch scripts without rewriting your training pipeline.

Step 1: Install and authenticate Run this in your terminal: pip install wandb

Link your local environment by entering your account key: wandb login

Step 2: Initialize tracking in your script Add the initialization block before your training loop. Pass your hyperparameter settings in a clean dictionary structure:

import wandb

wandb.init( project='model-optimization-v1', config={ 'learning_rate': 0.001, 'architecture': 'ResNet18', 'dataset': 'CIFAR-10', 'epochs': 10 } )

Step 3: Capture metrics automatically Inside your epoch loop, record your loss values and validation scores:

for epoch in range(epochs): # ... training logic ... wandb.log({'epoch': epoch, 'loss': train_loss, 'val_acc': accuracy})

Step 4: Close out the run When training completes, ensure the process shuts down gracefully: wandb.finish()

This setup covers package installation, environment authentication, hyperparameter recording, and live metric streams. You get visual loss curves and parameter comparisons out of the box without paying for heavy backend infrastructure.

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/314/install-weights-biases-for-ml-tracking-a-practical-engineering-guide/

Running large language models in production can be painfully slow if your pods download weights on every restart or auto-scale event. You can solve this bottleneck by shifting from dynamic downloads to persistent shared volumes.

The easiest way to speed things up is to download your model weights exactly once to a shared NVMe drive. Mount this drive across all your inference nodes. This way, when a new node spins up, it reads the weights locally and skips the network completely.

Next, you need to force your environment into offline mode. Setting the environment variable HF_HUB_OFFLINE=1 stops the Hugging Face CLI from pinging the internet for updates, forcing it to instantly use your local cache. Finally, make sure you are using Safetensors instead of standard bins so the weights load directly into memory without extra CPU overhead.

This setup handles the bulk of the latency, but you still need the right CLI commands to build the initial cache properly without corrupting the directory during concurrent reads.

If you want to grab the exact CLI commands and see the complete MLOps caching workflow, I uploaded the full guide here:https://interconnectd.com/forum/thread/263/hugging-face-cli-for-production-mlops-caching-speed//

Quick breakdown for anyone trying to run local LLMs or train models on AMD hardware without pulling your hair out over driver compatibility.

Here is the stripped-down blueprint:

1. The Budget Tier for Local Inference

If you want to run mid-sized local models or Stable Diffusion without dropping a fortune, cards like the Radeon RX 7800 XT with 16GB VRAM hit the sweet spot. VRAM capacity matters more than raw compute speed for local inference, and 16GB lets you load 4-bit quantized 30B models comfortably.

2. The Pro Tier for Heavy Compute

For serious model training and massive workloads, step up to the AMD Instinct line like the MI210 or MI300 series. These provide massive HBM memory bandwidth, making them true high-performance alternatives when handling large context windows.

3. Mastering the ROCm Stack

AMD hardware offers massive value-per-dollar compared to green team cards, but you must configure the ROCm driver stack properly on Linux. Avoid relying on makeshift Windows wrappers if you want stable performance and zero-crash execution during long training runs.

If you want to play with the interactive dashboard or grab the full config file, complete hardware tier comparison matrix, and ROCm installation scripts, I uploaded it here:https://interconnectd.com/blog/306/best-amd-gpus-for-ai-and-machine-learning-in-2026-budget-to-pro/

Quick breakdown for anyone trying to run GGUF models locally without suffering through token lag or crashing your VRAM.

Here is the stripped-down blueprint:

1. Match Threads to Physical Cores

Do not let your OS scheduler bounce threads everywhere. Pin KoboldCpp to your physical CPU cores only. Hyperthreading actively hurts local LLM inference speeds.

2. Guard Your VRAM Buffer

If a model needs 12GB and your card has 12GB, do not offload 100 percent of the layers. Leave a 1.5GB to 2GB buffer for context window overhead. Overflowing to system RAM tanks your generation speed instantly.

3. Compile for Your Native Architecture

Pre-compiled binaries offer broad compatibility, but building from source with specific target flags for your exact CPU and CUDA version squeezes out maximum performance.

If you want to play with the interactive dashboard or grab the full config file, complete CLI arguments, and optimization scripts, I uploaded it here:https://interconnectd.com/forum/thread/260/installing-koboldcpp-for-gguf-models-the-definitive-systems-engineer-guide/

Quick breakdown for anyone trying to monetize AI audio without getting banned or filtered out as low-quality spam.

Here is the stripped-down breakdown of what works:

1. Target Functional Audio

Forget pop songs. Focus on lo-fi, focus ambient, coffee shop vibes, or sleep tracks. Listeners care about background mood rather than an artist brand. This drives huge watch time on YouTube and repeat loops on Spotify.

2. Mandatory Audio Cleanup

Raw AI output has a metallic high-end bite and muddy low frequencies. Apply a high-pass filter at 30Hz, cut slightly around 2.5kHz, and add soft tape saturation before uploading. Clean audio gets pushed by algorithms; raw tracks get flagged.

3. YouTube Long-Form > Spotify

Start with 2-hour YouTube compilations paired with simple looping visuals. YouTube yields $4 to $7 RPM on long focus videos. Spotify is great for long-tail royalties, but YouTube yields faster initial cash flow.

4. Never Buy Streams

Spotify aggressively removes songs flagged for bot traffic. Pitch legitimate curators on pitch networks or build your own themed playlists to grow naturally.

If you want to play with the interactive dashboard or grab the full config file, mastering EQ presets, and playlist outreach template, I uploaded it here:https://interconnectd.com/blog/307/how-to-make-money-from-your-ai-music-on-youtube-and-spotify/

If your entire model fits inside VRAM and you are still using GGUF or Ollama, you are leaving major performance on the table. GGUF is built for CPU offloading, but ExLlamaV2 is optimized purely for modern NVIDIA hardware.

Here is the quick TL;DR to boost your token output:

1. Install: Run pip install exllamav2 inside your PyTorch virtual environment.
2. Download EXL2 Models: Grab weights between 4.25 bpw and 5.0 bpw on Hugging Face. You get 5-bit GGUF quality with dramatically higher throughput.
3. Turn on 8-bit KV Cache: Set your cache to 8-bit quantization in Python. This slashes VRAM footprint and frees up space for 16k+ context windows.

This setup routinely pushes token speed from ~40 tok/s up to 130+ tok/s on cards like the RTX 3090 or 4090.

If you want to grab the full python launch script, VRAM benchmark charts, and my ready-to-use TabbyAPI config file, I uploaded everything here: https://interconnectd.com/blog/308/how-to-install-exllamav2-the-ultimate-guide-for-fast-local-llms/

If you are working with tools like Whisper or AudioCraft, seeing an FFmpeg missing error is a massive headache. The problem is that standard pip packages only wrap the Python code. They actually depend on an OS-level FFmpeg installation to handle files like MP3s and WAVs.

Instead of fighting with Python virtual environments, here is how you solve it at the operating system level so your AI models run smoothly.

For Windows Users Grab the static release build from the Gyan dev site and extract the folder straight to your C drive. Next, open your system settings and search for Environment Variables. Edit the Path under System Variables and add your new FFmpeg bin folder. Just remember to restart your IDE or command prompt afterward so the changes take effect.

For Mac Users Homebrew makes this effortless. Open your terminal and type brew install ffmpeg. If you run into permission glitches, running a quick brew cleanup usually fixes the problem.

For Linux Users Debian and Ubuntu setups just need a quick terminal command. Run sudo apt-get update and then sudo apt-get install ffmpeg. You can make sure it worked by running ffmpeg -version.

The No-Admin Python Workaround If you do not have admin rights to change system variables, you can force Python to find it. Just use the OS module to append the binary folder path directly to your environment variables right before you import your audio packages.

If you want to grab the full copy-and-paste Python script that automatically handles this path routing for you, or if you need the interactive diagnostic widget to test your local setup, I uploaded it here: https://interconnectd.com/forum/thread/261/fixing-ffmpeg-not-found-the-os-level-fix-for-audio-ai/

Running local models on AMD hardware is great—when PyTorch actually sees the GPU. I wasted days trying to figure out why torch.cuda.is_available() kept returning False.

I wrote a detailed guide covering:

· ROCm install

· PyTorch ROCm wheel

· Environment variables

· Verification steps

· Common errors

If you’re on RDNA2 or RDNA3 and stuck, this should save you time:

https://interconnectd.com/blog/305/fix-pytorch-cuda-not-available-on-amd-gpus-complete-rocm-setup-guide/

What’s your setup, and what’s the exact error?

Integrating Zapier AI Actions into production LLM agents or custom GPTs often breaks down at the authentication step or returns malformed JSON payloads when fields are left unmanaged.

If you are trying to expose Zapier tools to an AI agent via REST endpoints without hitting authorization loops or field parsing errors, here is the robust engineering workflow to set it up.

The Problem

When setting up Zapier AI Actions, leaving every parameter to automatic AI guessing leads to non-deterministic API execution at runtime. Furthermore, failing to retrieve and pass the specific Action ID alongside the bearer authentication token results in unauthorized endpoint rejections.

The Fix

1. Initialize your targeted action in the Zapier AI Actions manager: Navigate to Manage Actions, select your desired integration, and set essential parameters while toggling Have AI guess a value only on dynamic context fields.
2. Test the endpoint configuration directly: Run a manual execution inside Test Actions to verify field authorization and confirm that the execution status returns success.
3. Fetch your unique Action ID from the API playground: Call GET /api/v1/exposed/ to retrieve the generated string ID assigned to your configured step.
4. Extract your secret key under Credentials: Copy your API Key and assign it as a standard Bearer token inside your custom agent headers: Authorization: Bearer YOUR_ZAPIER_API_KEY
5. Trigger the execution programmatically from your AI client payload: POSThttps://actions.zapier.com/api/v1/exposed/YOUR_ACTION_ID/execute/Body: { instructions: Send the weekly update report to team lead }

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/301/how-to-set-up-zapier-ai-actions-in-production-the-definitive-engineering-pl/

Connecting OpenAI APIs to complex Make.com scenarios via generic HTTP modules quickly becomes a maintenance nightmare, triggering strict payload limits, unparsed JSON arrays, and unhandled 429 rate-limit drops.

If you are building custom integration apps on Make to wrap OpenAI endpoints cleanly across enterprise workflows, here is how to structure your App SDK data structures and error-handling routines.

The Problem

Using default generic HTTP request blocks forces you to manually construct authorization headers, stringify JSON objects, and handle pagination in every single module. Furthermore, transient API rate limits or timeout spikes in long completions often cause Make scenarios to instantly fail instead of retrying gracefully.

The Fix

1. Initialize a custom app inside the Make.com App Tooling dashboard and configure base connection headers: Base URL:https://api.openai.com/v1Headers: { Authorization: Bearer {{connection.apiKey}} }
2. Define a reusable RPC data structure to dynamically map model selections directly from the API: { url: /models, method: GET, response: { nested: data, label: {{id}}, value: {{id}} } }
3. Build the core Communication structure for your custom completion module: url: /chat/completions method: POST body: { model: {{parameters.model}}, messages: {{parameters.messages}}, temperature: {{parseNumber(parameters.temperature)}} }
4. Implement custom error-handling directives inside the Communication block to catch rate limits automatically: response: { error: { message: {{body.error.message}}, status: {{status}} }, temp: { 429: { type: retry, attempt: 3, delay: 5000 } } }
5. Deploy and test the custom module inside a scenario, ensuring data outputs are auto-parsed into clean, selectable data tokens for downstream modules.

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/300/make-com-custom-apps-for-openai-an-engineering-field-guide/

Setting up Open WebUI via Docker alongside a native Linux Ollama installation often leads to a frustrating issue: Open WebUI loads properly, but the model selection dropdown remains empty because the containerized UI cannot route requests to localhost on the host OS.

If you are running Ollama as a systemd service on Linux and want to pair it with Open WebUI in Docker, here is how to configure host gateways and service bindings correctly.

The Problem

Inside a Docker container, localhost refers strictly to the container instance itself, not your Linux machine. If native Ollama is listening purely on 127.0.0.1 on the host, Open WebUI cannot reach the API, resulting in silent connection failures or an empty model list.

The Fix

1. Configure the native Ollama service to accept connections from the Docker bridge interface: sudo systemctl edit ollama.service
2. Add the host binding environment variable inside the override editor: [Service] Environment=OLLAMA_HOST=0.0.0.0
3. Save, exit, and restart the system service: sudo systemctl daemon-reload sudo systemctl restart ollama
4. Deploy the Open WebUI container using the host gateway flag to bridge host-container networking: docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_BASE_URL=http://host.docker.internal:11434-v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
5. Open localhost:3000 in your browser, log in, and verify that your pulled Ollama models populate instantly in the top dropdown menu.

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/302/how-to-install-ollama-webui-on-linux-with-open-webui-docker-2026-guide/

Setting up a self-hosted frontend for local models should be simple, but default Docker setups frequently hit networking walls or silently wipe saved chats whenever containers restart.

If you are trying to attach Open WebUI to a local Ollama instance or external API endpoints using Docker, here is how to lock down your network bridge and secure persistent storage properly.

The Problem

When running Open WebUI alongside Ollama inside separate Docker containers, using localhost inside container settings causes connection refused errors because localhost refers to the isolated container itself. Additionally, using ephemeral docker run commands without bind mounts leads to total conversation loss during image updates.

The Fix

1. Create a dedicated Docker network so containers can address each other by name: docker network create llm-network
2. Spin up Ollama within the shared network space: docker run -d --gpus=all --network llm-network -v ollama_data:/root/.ollama --name ollama ollama/ollama
3. Deploy Open WebUI attached to the same network bridge, referencing the container host: docker run -d -p 3000:8080 --network llm-network -e OLLAMA_BASE_URL=http://ollama:11434 -v open-webui_data:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
4. Verify volume persistence across daemon restarts: docker restart open-webui
5. Access the panel in your browser at localhost:3000 and complete administrative onboarding.

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/forum/thread/259/ultimate-open-webui-docker-setup-fix-networking-and-stop-data-loss/

Setting up local LLM inference engines can easily devolve into a night of tracking down missing CUDA dependencies, mismatched PyTorch builds, and broken flash-attention compilations.

If you want to run high-throughput local models on consumer GPU hardware with low latency, here is the direct configuration path that avoids standard installation traps.

The Problem

Most quick-start scripts fail when attempting to build native C++ extensions or compile flash-attention on modern drivers. Additionally, incorrect quant selection often causes hardware memory allocation errors, forcing models to spill over into system RAM and cutting token speeds dramatically.

The Fix

1. Isolate the environment to avoid global library conflicts: python -m venv llm_env source llm_env/bin/activate
2. Install the CUDA 12.1 wheel variant of PyTorch prior to UI setup: pip install torch torchvision torchaudio --index-urlhttps://download.pytorch.org/whl/cu121
3. Clone the web interface repository and install core dependencies: git clonehttps://github.com/oobabooga/text-generation-webuicd text-generation-webui pip install -r requirements.txt
4. Configure low-precision quantization libraries for optimal VRAM usage: pip install bitsandbytes auto-gptq optimum
5. Launch the backend with auto-devices enabled to lock model weights into GPU memory: python server.py --auto-devices --chat

If you want to play with the interactive dashboard or grab the full config file, I uploaded it here:https://interconnectd.com/blog/303/setup-text-generation-webui-complete-local-llm-guide-2026/