awesome-repositories.com
Blog
MCP
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektMCP-ServerÜber unsRanking-MethodikPresse
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

373 Repos

Awesome GitHub RepositoriesFile-Based Configuration

Configuration management using structured files.

Explore 373 awesome GitHub repositories matching devops & infrastructure · File-Based Configuration. Refine with filters or upvote what's useful.

Awesome File-Based Configuration GitHub Repositories

Finde die besten Repos mit KI.Wir suchen mit KI nach den am besten passenden Repositories.
  • affaan-m/eccAvatar von affaan-m

    affaan-m/ECC

    221,981Auf GitHub ansehen↗

    ECC ist ein LLM-Agenten-Orchestrierungs-Framework und eine plattformübergreifende KI-Tool-Suite, die darauf ausgelegt ist, Multi-Modell-Workflows zu koordinieren. Es bietet ein System zur Verwaltung spezialisierter Agentenrollen, wiederverwendbarer Fähigkeiten und strukturierter Planung, um komplexe Softwareentwicklungsaufgaben über verschiedene KI-gestützte Code-Editoren hinweg auszuführen. Das Projekt zeichnet sich als Model Context Protocol Manager aus und bietet eine Konfigurationsschicht zur Integration externer Server und zur Prüfung der Tool-Ausführung. Es implementiert zudem eine agentische Sicherheits-Sandbox, die den Zugriff auf sensible Dateien einschränkt und auf Geheimnislecks scannt, um autonome Workflows zu sichern. Das Framework deckt breite Fähigkeitsbereiche ab, einschließlich der Automatisierung von KI-Coding-Workflows mit Leitplanken für testgetriebene Entwicklung, Modellkostenoptimierung durch intelligentes Routing und zustandsisoliertes Speichermanagement. Es enthält zudem Tools zur Durchsetzung sprachspezifischer Codierungsstandards und zur Verwaltung von Agentenverhalten über verschiedene integrierte Entwicklungsumgebungen hinweg. Das System wird über eine Befehlszeilenschnittstelle verwaltet, die die Tool-Installation, Konfigurationsreparatur und die Bereitstellung von Tool-Presets handhabt.

    Implements an add-only strategy to combine new server and tool settings without overwriting user preferences.

    JavaScript
    Auf GitHub ansehen↗221,981
  • thealgorithms/javaAvatar von TheAlgorithms

    TheAlgorithms/Java

    65,843Auf GitHub ansehen↗

    This project is an educational repository containing a comprehensive collection of classic computer science algorithms and data structures implemented in Java. It serves as a community-driven learning resource designed to help students and developers study fundamental computational problems and practice idiomatic syntax through clean, well-documented code examples. The repository distinguishes itself by using decoupled logic encapsulation, which isolates individual algorithmic implementations into independent classes to ensure modularity. It further enforces standardized method signatures acr

    Ships container definitions that simplify the deployment of consistent development environments for all users.

    Javaalgorithmalgorithm-challengesalgorithms
    Auf GitHub ansehen↗65,843
  • adam-p/markdown-hereAvatar von adam-p

    adam-p/markdown-here

    60,218Auf GitHub ansehen↗

    Markdown Here is a browser extension that enables rich text composition within web-based editors that lack native formatting support. By transforming plain text markdown syntax into rendered HTML, it allows users to draft professional emails and documents using standard markup, including headers, tables, and footnotes, directly inside their browser. The tool distinguishes itself through a bidirectional transformation engine that supports both the conversion of markdown to HTML and the reversion of rendered content back into its original source code. This state-preserving functionality allows

    Leverages local browser storage APIs to maintain persistent user preferences and configuration settings across multiple browsing sessions.

    JavaScript
    Auf GitHub ansehen↗60,218
  • ultralytics/yolov5Avatar von ultralytics

    ultralytics/yolov5

    57,528Auf GitHub ansehen↗

    YOLOv5 is a comprehensive computer vision framework designed for end-to-end deep learning, specializing in real-time object detection, image classification, and instance segmentation. It provides a unified toolkit that manages the entire lifecycle of a model, from initial dataset configuration and hyperparameter tuning to high-speed inference and deployment. The framework utilizes a modular neural architecture, allowing users to swap backbone and head components to tailor models for specific visual tasks. What distinguishes this project is its focus on production-ready deployment and model ef

    Maintains system settings and dataset schemas in external text files to separate operational logic from underlying data paths.

    Pythoncoremldeep-learningios
    Auf GitHub ansehen↗57,528
  • zylon-ai/private-gptAvatar von zylon-ai

    zylon-ai/private-gpt

    57,278Auf GitHub ansehen↗

    This project is a privacy-first backend service designed to facilitate retrieval-augmented generation by processing local documents into searchable vector representations. It provides a modular architecture that allows users to ingest diverse file formats, manage document metadata, and perform semantic searches to provide context-aware responses for chat and completion requests. The system distinguishes itself through a database-agnostic abstraction layer that supports various storage backends, ranging from local disk storage to enterprise-grade vector databases. It offers flexible deployment

    Detect available configuration profiles by scanning the designated settings directory for valid file patterns.

    Python
    Auf GitHub ansehen↗57,278
  • etcd-io/etcdAvatar von etcd-io

    etcd-io/etcd

    51,838Auf GitHub ansehen↗

    etcd is a distributed, strongly consistent key-value store designed to provide reliable storage for critical system metadata and coordination primitives. It functions as a distributed consensus engine, utilizing a replicated log and leader-based state machine to ensure that all nodes in a cluster maintain a synchronized view of data. By providing atomic operations and linearizable reads and writes, it serves as a foundational component for distributed systems requiring high availability and fault tolerance. The system distinguishes itself through its multi-version concurrency control, which e

    Structured YAML files map configuration parameters to values for managing complex deployment environments.

    Gocncfconsensusdatabase
    Auf GitHub ansehen↗51,838
  • harness/harnessAvatar von harness

    harness/harness

    36,937Auf GitHub ansehen↗

    Harness is an end-to-end developer platform and DevOps orchestration tool designed to automate software build, test, and deployment pipelines. It functions as a CI/CD platform and a source code management system for hosting and managing version-controlled repositories. The platform provides a remote development environment that launches ephemeral, cloud-based coding spaces to ensure standardized setups. It also includes a centralized artifact registry for storing and managing versioned binary packages and container images used in delivery pipelines. The system covers broad capability areas i

    Uses structured configuration files to define build and delivery sequences for the orchestration engine.

    Gobuild-automationbuild-pipelinesci
    Auf GitHub ansehen↗36,937
  • sdispater/poetryAvatar von sdispater

    sdispater/poetry

    34,282Auf GitHub ansehen↗

    Poetry is a Python build tool, dependency manager, and project orchestrator. It provides a unified workflow for managing the full lifecycle of a project, from initial environment setup to the final package release. The system centralizes project metadata and dependency specifications in a single configuration file, replacing legacy formats. It utilizes a deterministic dependency resolver to calculate compatible package versions and records the exact state of the environment in a lock file to ensure consistency across different machines. The tool handles the orchestration of isolated virtual

    Centralizes project metadata and dependencies in a single pyproject.toml file, replacing legacy configuration formats.

    Python
    Auf GitHub ansehen↗34,282
  • searxng/searxngAvatar von searxng

    searxng/searxng

    32,180Auf GitHub ansehen↗

    This project is a privacy-focused, self-hosted metasearch engine that aggregates results from a wide array of web, academic, and media sources into a single, unified interface. By acting as a proxy between the user and external search providers, it strips identifying headers and tracking parameters from requests, ensuring that search activity remains anonymous and protected from third-party profiling. The platform distinguishes itself through a modular, plugin-based architecture that allows for extensive customization of search behavior, result filtering, and interface branding. It supports a

    Loads and validates application settings from structured files to define system parameters.

    Pythonbingbravedegoogle
    Auf GitHub ansehen↗32,180
  • zeroclaw-labs/zeroclawAvatar von zeroclaw-labs

    zeroclaw-labs/zeroclaw

    31,920Auf GitHub ansehen↗

    Zeroclaw is a modular framework for building and deploying autonomous agents that integrate AI models, messaging platforms, and hardware interfaces. It functions as a multi-agent orchestrator and embedded systems controller, providing a unified runtime for managing agent lifecycles, memory, and security policies across diverse environments. The system distinguishes itself through its focus on secure, verifiable hardware and software orchestration. It enforces strict security boundaries, including command allowlisting, resource throttling, and interactive human-in-the-loop approval for sensiti

    Standardizes the visual structure and formatting of configuration files across the codebase.

    Rust
    Auf GitHub ansehen↗31,920
  • nvim-lua/kickstart.nvimAvatar von nvim-lua

    nvim-lua/kickstart.nvim

    30,856Auf GitHub ansehen↗

    Kickstart.nvim is a foundational boilerplate designed for building personalized Neovim environments. It provides a structured framework that uses Lua scripting to organize editor settings and custom logic, serving as a starting point for users to develop their own text editing workflows. The project distinguishes itself by integrating a centralized plugin manager that automates the installation, versioning, and lazy-loading of extensions. This orchestration minimizes startup latency while maintaining a declarative approach to managing the lifecycle of editor tools. The framework supports mod

    Organizes complex configuration logic into modular, dynamically required files.

    Lua
    Auf GitHub ansehen↗30,856
  • trailofbits/algoAvatar von trailofbits

    trailofbits/algo

    30,278Auf GitHub ansehen↗

    Algo is a cloud VPN deployment tool and WireGuard orchestrator designed to automate the provisioning and configuration of personal VPN servers across multiple cloud infrastructure providers. It functions as a multi-cloud infrastructure provisioner and a VPN client configuration generator, creating the necessary tunnels and connection profiles for secure device connectivity. The project distinguishes itself by integrating a network ad-blocking DNS server directly into the deployment, filtering advertisements and malicious domains for all connected clients. It further simplifies the onboarding

    Generates protocol-specific configuration files, QR codes, and system profiles for multiple operating systems.

    Pythonansibleencryptionikev2
    Auf GitHub ansehen↗30,278
  • dylanaraps/neofetchAvatar von dylanaraps

    dylanaraps/neofetch

    23,556Auf GitHub ansehen↗

    Neofetch is a command-line utility that gathers and displays hardware, software, and environment details in the terminal. It functions as a cross-platform system reporter, capable of detecting and summarizing metrics across Linux, macOS, Windows, and various Unix-like environments. The tool distinguishes itself through its terminal graphics rendering capabilities, which allow for the display of custom ASCII art or graphical images alongside system data. It utilizes a modular backend to interface with diverse operating systems and desktop environments, while employing parallel execution to gat

    Allows ASCII art configuration by defining custom text-based logos or images using specific file formats for terminal rendering.

    Shellbashcommand-linecommandline
    Auf GitHub ansehen↗23,556
  • aldanial/clocAvatar von AlDanial

    AlDanial/cloc

    23,201Auf GitHub ansehen↗

    cloc is a codebase metrics tool and multi-language code analyzer designed to count blank lines, comment lines, and physical lines of code. It serves as a source code line counter and report generator that identifies file types to calculate source volume across a wide variety of programming languages. The tool distinguishes itself by providing codebase version comparison to measure relative changes in source and comment lines between two versions of a directory or archive. It also supports the definition of custom languages and the extension of language recognition by loading custom comment fi

    Supports loading recurring command line switches from a persistent configuration file.

    Perl
    Auf GitHub ansehen↗23,201
  • mochajs/mochaAvatar von mochajs

    mochajs/mocha

    22,967Auf GitHub ansehen↗

    Mocha is a JavaScript test runner and framework designed to execute automated test suites across multiple runtimes, including Node.js and web browser environments. It functions as a pluggable testing tool for organizing and validating unit, integration, and functional tests. The project distinguishes itself through a plugin-based extension interface that allows for custom functionality and reporting. It supports a multi-runtime approach, enabling the same test suite to run in different JavaScript environments, and includes a watch mode that monitors the filesystem to trigger automatic test re

    Supports loading runtime settings via JSON, YAML, or JavaScript configuration files.

    JavaScriptbddbrowserjavascript
    Auf GitHub ansehen↗22,967
  • prefecthq/fastmcpAvatar von PrefectHQ

    PrefectHQ/fastmcp

    22,994Auf GitHub ansehen↗

    FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

    Updates existing configuration files with new server definitions while preserving current settings.

    Pythonagentsfastmcpllms
    Auf GitHub ansehen↗22,994
  • vueuse/vueuseAvatar von vueuse

    vueuse/vueuse

    22,092Auf GitHub ansehen↗

    This project is a comprehensive collection of modular, reactive functions designed to streamline the development of user interfaces. It serves as a toolkit for managing application state, wrapping native browser hardware and system features, and encapsulating common logic patterns into reusable units. By binding asynchronous data sources, browser events, and system properties to component state, it provides a unified framework for building interactive web and desktop applications. The library distinguishes itself through its focus on composition and lifecycle management, allowing developers t

    Provides mechanisms for saving and retrieving user settings using browser-native storage APIs.

    TypeScriptcomposableutility-libraryvue
    Auf GitHub ansehen↗22,092
  • lima-vm/limaAvatar von lima-vm

    lima-vm/lima

    21,320Auf GitHub ansehen↗

    Lima is a virtualization engine designed to provision and manage lightweight Linux, macOS, and FreeBSD virtual machines. It functions as a comprehensive virtual machine manager that leverages native hypervisors and system emulation to provide isolated environments for container development, cross-architecture testing, and secure sandboxing. The project distinguishes itself through its template-driven provisioning system, which allows users to define and automate environment configurations via local files or remote URL schemes. It integrates deeply with host systems by providing automated file

    Updates virtual machine settings by opening configuration files in a text editor.

    Gocontainerdmacosqemu
    Auf GitHub ansehen↗21,320
  • python/mypyAvatar von python

    python/mypy

    20,489Auf GitHub ansehen↗

    mypy is a static type checker for Python that analyzes source code to detect type errors and inconsistencies without executing the program. It functions as a static analysis tool and type inference engine, providing a gradual typing system that allows type hints to be added to a codebase incrementally while maintaining compatibility with dynamic typing. The project distinguishes itself through a combination of performance and precision features. It utilizes a daemon-based incremental checking system and multi-process parallel analysis to manage large codebases, supported by binary cache persi

    Recursively searches the filesystem for project configuration files to resolve analysis settings.

    Pythonlinterpythontypechecker
    Auf GitHub ansehen↗20,489
  • toml-lang/tomlAvatar von toml-lang

    toml-lang/toml

    20,525Auf GitHub ansehen↗

    TOML is a configuration file format designed for human readability and unambiguous mapping to hash tables. It serves as a standardized language for structured data, enabling consistent parsing and data exchange across diverse programming environments. The format distinguishes itself through a strict type-system specification that ensures data is interpreted identically regardless of the implementation. It utilizes a line-oriented lexical structure that supports both hierarchical organization through bracketed sections and compact inline embedding for nested objects. This approach allows for t

    Supports inserting human-readable notes into configuration files using designated symbols.

    Auf GitHub ansehen↗20,525
Vorherige123456…19Nächste
  1. Home
  2. DevOps & Infrastructure
  3. Configuration Management
  4. File-Based Configuration

Unter-Tags erkunden

  • ASCII Art ConfigurationsConfiguration files for defining custom text-based logos and terminal graphics. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on ASCII art logo definitions rather than general application settings.
  • Adapter-Based Loaders1 Sub-TagMechanisms that map diverse data sources into a unified internal configuration structure using adapters. **Distinct from File-Based Configuration:** Distinct from general file-based configuration by supporting multiple adapter sources including remote centers.
  • Agent Configuration FilesPlain-text configuration files placed in the project root that define agent behavior and tool integrations. **Distinct from File-Based Configuration:** Distinct from general File-Based Configuration: specifically targets agent behavior and tool integration configuration rather than generic application settings.
  • Automated Configuration Updates1 Sub-TagAutomated processes for updating local configuration files based on environment triggers. **Distinct from File-Based Configuration:** Focuses on the automation of updating the file rather than just the structure of the file-based configuration
  • Browser Storage PersistenceMechanisms for saving and retrieving user settings using browser-native storage APIs.
  • Cloud File Attribute Modifiers1 Sub-TagUtilities for renaming and updating metadata of files stored in cloud drives. **Distinct from File Attribute Modifiers:** Distinct from File Attribute Modifiers: targets cloud-based Drive files via API rather than local configuration files.
  • Configuration Discovery ToolsUtilities that scan and identify available configuration profiles within a file system.
  • Configuration File Loading31 Sub-TagsMechanisms for scanning and parsing structured configuration files to determine runtime behavior. **Distinct from File-Based Configuration:** Focuses on the process of loading and resolving settings from files like JSON or YAML
  • Configuration Migration2 Sub-TagsTools for transforming configuration file structures while preserving settings. **Distinct from File-Based Configuration:** Focuses on the transformation and migration of file formats, not just the static management of structured files.
  • Configuration Profiles12 Sub-TagsManages multiple proxy configuration profiles stored as YAML files, supporting hot reloads and switching. **Distinct from File-Based Configuration:** Focuses on managing multiple proxy configuration profiles rather than a single configuration file.
  • Custom Resource MappingsTranslating high-level custom resource definitions into specific configuration files for underlying software. **Distinct from File-Based Configuration:** Focuses on the translation from Kubernetes Custom Resources to config files, rather than general file-based settings.
  • Dependency Lock FilesConfiguration files that lock specific versions of dependencies to ensure environment consistency. **Distinct from File-Based Configuration:** Specifically addresses version locking for dependencies, not general system or application configuration.
  • Dockerfile ExamplesReference implementations and templates for container image definitions.
  • EditorsUtilities for modifying configuration files directly within the terminal environment. **Distinct from File-Based Configuration:** Focuses on the act of editing configuration files, distinct from general file-based configuration storage.
  • File Attribute Modifiers1 Sub-TagTools for updating metadata and processing flags for managed configuration files. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on the modification of file metadata and attributes rather than the configuration content itself.
  • File Permission Inspection2 Sub-TagsUtilities for checking file system metadata, such as executability, for use in conditional configuration logic. **Distinct from File-Based Configuration:** Focuses on inspecting file permissions for template logic, distinct from general file-based configuration.
  • Managed Configuration UpdatesProcesses for refreshing the source state with local changes while preserving encryption and template metadata. **Distinct from File-Based Configuration:** Focuses on updating the managed source state, distinct from general file-based configuration.
  • Managed File Inventories2 Sub-TagsProvides tools to list and filter tracked configuration files. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on the inventory and listing capability rather than the configuration management itself.
  • Managed File Removal4 Sub-TagsOperations for untracking and deleting specific files from both source and destination environments. **Distinct from File-Based Configuration:** Focuses on the removal of managed files from the synchronization state, distinct from general file deletion.
  • Profile Generators1 Sub-TagTools that automate the creation of standardized configuration files for network clients. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on the generation and distribution of client-specific profiles rather than general configuration parsing.
  • Project Metadata Specifications2 Sub-TagsStandardized files used to define project dependencies and metadata for build tools. **Distinct from File-Based Configuration:** Focuses on the specific schema for project definition rather than general application configuration files.
  • Remote Configuration File OperationsReading and updating configuration files and environment variables on remote systems via scripted file operations. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on remote file operations over SSH rather than local file parsing.
  • Shell Plugin MappingMapping of shell plugins and themes to filesystem structures for dynamic sourcing. **Distinct from File-Based Configuration:** Specific to shell startup sourcing rather than general application configuration files
  • Tracking ExclusionsMechanisms for removing files from the synchronization scope to prevent them from being updated or tracked. **Distinct from File-Based Configuration:** Focuses on the exclusion of files from management, distinct from general file-based configuration.
  • Unmanaged File DetectorsUtilities for scanning directories to identify files not currently tracked by the configuration management system. **Distinct from File-Based Configuration:** Distinct from File-Based Configuration: focuses on auditing and drift detection rather than the configuration files themselves.