{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"vscode-marcflausino-codigo-generator","slug":"codigo-generator","name":"codigo-generator","type":"extension","url":"https://marketplace.visualstudio.com/items?itemName=MarcFlausino.codigo-generator","page_url":"https://unfragile.ai/codigo-generator","categories":["code-editors"],"tags":["AI","artificial-intelligence","database","framework","generator","orm","tool"],"pricing":{"model":"freemium","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"vscode-marcflausino-codigo-generator__cap_0","uri":"capability://code.generation.editing.database.schema.to.code.generation","name":"database-schema-to-code-generation","description":"Reads database schema from MySQL, MariaDB, or PostgreSQL connections and generates multi-file code artifacts (models, repositories, services, controllers) in a single batch operation. The extension parses the database connection configuration from JSON config + .env files, introspects the schema metadata, and applies language/framework-specific code templates to produce boilerplate code. Supports TypeScript, PHP, Java, Python, and C# with framework-specific processors (e.g., Doctrine for PHP/Symfony).","intents":["Generate model and repository classes from an existing database schema to bootstrap a new project","Create CRUD service layers and API controllers automatically from database structure","Reduce manual boilerplate coding when starting a new feature with database-first design","Scaffold a complete project structure from a database schema in minutes instead of hours"],"best_for":["Backend developers building CRUD-heavy applications with database-first architecture","Teams using Symfony, Laravel, or other framework ecosystems with ORM/repository patterns","Developers prototyping MVPs who need rapid scaffolding from existing database schemas"],"limitations":["Supports only MySQL, MariaDB, and PostgreSQL — no support for NoSQL, SQLite, or other relational databases","Language/framework support is incomplete and evolving ('hopefully more to come') — only TypeScript, PHP, Java, Python, C# documented","Many-to-many relationship detection depends on naming convention (configurable separator like '_has_') — non-standard pivot table names may not be recognized","No built-in support for custom code generation templates — limited to predefined processors per framework","Generated code is boilerplate only — does not include business logic, validation rules, or domain-specific patterns"],"requires":["Visual Studio Code (minimum version unknown — documentation incomplete)","Active database connection to MySQL, MariaDB, or PostgreSQL with read access to schema metadata",".env file in project root with database credentials (host, user, password, port, database name)","JSON configuration file specifying db_type, database connection details, template/framework, packageBaseName, and out_folder","Write permissions to the configured out_folder directory"],"input_types":["database-schema-metadata (introspected from live database connection)","json-configuration (global_config and processors array)","environment-variables (from .env file with ${VAR_NAME} interpolation)"],"output_types":["source-code-files (TypeScript, PHP, Java, Python, C# depending on template)","multiple-files (models, repositories, services, controllers written to out_folder)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_1","uri":"capability://code.generation.editing.ai.enhanced.code.generation","name":"ai-enhanced-code-generation","description":"Optionally augments generated code files with AI refinement using ChatGPT API. After the base code generation pipeline produces boilerplate, the extension can send generated files to OpenAI's API for enhancement (if enabled and processor supports it). This is a post-processing step that improves code quality, adds documentation, or refactors generated code. AI enhancement is processor-dependent and explicitly documented as significantly increasing processing time.","intents":["Improve generated boilerplate code quality with AI-driven refactoring and optimization","Automatically add docstrings, type hints, and inline comments to generated code","Enhance generated code with best practices and design patterns specific to the target framework","Reduce manual code review and cleanup time after generation"],"best_for":["Teams with ChatGPT API access who prioritize code quality over generation speed","Developers working in languages/frameworks where generated code often requires significant manual cleanup","Projects where AI-enhanced documentation and type safety are valued"],"limitations":["AI enhancement is optional and processor-dependent — not all code generators support it (documentation incomplete on which processors have AI support)","Significantly increases processing time — no quantified timing data provided, but documented as material performance impact","Requires valid ChatGPT API key and active OpenAI account — adds per-request costs to generation workflow","No control over AI enhancement parameters (temperature, max tokens, system prompts) — all-or-nothing feature","AI output quality depends on ChatGPT's understanding of generated code context — may produce inconsistent or incorrect enhancements"],"requires":["useAI.enabled: true in JSON configuration","Valid OpenAI ChatGPT API key (stored in .env and referenced via ${CHATGPT_APIKEY} in config)","Active OpenAI account with API credits","Processor that supports AI enhancement (varies by framework/language)"],"input_types":["generated-source-code (output from base code generation pipeline)","processor-metadata (which processors support AI enhancement)"],"output_types":["ai-enhanced-source-code (ChatGPT-refined versions of generated files)"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_10","uri":"capability://code.generation.editing.package.namespace.configuration.for.generated.code","name":"package-namespace-configuration-for-generated-code","description":"Allows configuration of the base package/namespace name for generated code via the packageBaseName parameter in JSON config. This parameter is used by language-specific processors to generate code with the correct package structure (Java packages, PHP namespaces, Python modules, C# namespaces, TypeScript module paths). The extension applies this base name to all generated classes/modules without requiring manual post-processing.","intents":["Generate code with the correct package/namespace structure for the target project","Avoid manual renaming of generated code packages/namespaces","Support different package structures across development, staging, and production environments"],"best_for":["Developers who want generated code to integrate seamlessly with existing project structure","Teams with strict package/namespace naming conventions","Projects where package structure is part of the architecture (e.g., domain-driven design)"],"limitations":["Single base package name per configuration — cannot generate code for multiple packages in one run","No support for sub-packages or nested namespaces — all generated code uses the same base package","Processor-dependent implementation — unclear how each language/framework applies packageBaseName","No validation of package name format — invalid package names may produce syntax errors in generated code"],"requires":["packageBaseName parameter in JSON config (e.g., 'com.example.app', 'App\\Generated', 'app.models')","Valid package/namespace name format for the target language (Java: com.example.app, PHP: App\\Generated, etc.)"],"input_types":["packageBaseName-string (e.g., 'com.example.app')"],"output_types":["generated-code-with-package-structure (classes/modules with correct package/namespace)"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_2","uri":"capability://code.generation.editing.multi.language.code.generation.with.framework.templates","name":"multi-language-code-generation-with-framework-templates","description":"Generates code in multiple programming languages (TypeScript, PHP, Java, Python, C#) using framework-specific templates and processors. The extension selects a template (e.g., 'php' for Symfony/Doctrine) and applies language-specific code generation rules via named processors (e.g., doctrine_entity, doctrine_repository). Each processor knows how to generate idiomatic code for its target framework, handling language syntax, naming conventions, and framework-specific patterns.","intents":["Generate code in the same language and framework as the target project without manual conversion","Support polyglot teams working across multiple backend languages and frameworks","Create framework-idiomatic code (Doctrine entities vs Eloquent models) rather than generic boilerplate","Extend code generation to new languages/frameworks by adding new processors"],"best_for":["Polyglot development teams using multiple backend languages","Organizations standardized on specific frameworks (Symfony, Laravel, Spring, Django, .NET) who want framework-native generation","Developers building microservices in different languages who need consistent scaffolding patterns"],"limitations":["Language support is incomplete and evolving — only TypeScript, PHP, Java, Python, C# documented with 'hopefully more to come'","Framework support is undocumented — documentation references 'list below for supported frameworks and integrations' but list is truncated","No clear extension mechanism for adding new languages/frameworks — processor architecture not documented for third-party contributions","Each language/framework requires separate processor implementation — maintenance burden grows with each new target","No cross-language code sharing or common patterns — each processor is isolated"],"requires":["template parameter in JSON config specifying target language/framework (e.g., 'php')","packageBaseName parameter for namespace/package naming in target language","processors array with framework-specific processor names (e.g., doctrine_entity, doctrine_repository)","Target language compiler/runtime available (implicit — code is generated but not compiled/executed by extension)"],"input_types":["template-identifier (string like 'php', 'typescript', 'java')","processor-names (array of framework-specific processor identifiers)","database-schema (introspected from database)"],"output_types":["language-specific-source-code (TypeScript, PHP, Java, Python, C# files)","framework-idiomatic-code (Doctrine entities, Eloquent models, Spring repositories, etc.)"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_3","uri":"capability://data.processing.analysis.environment.variable.interpolation.in.configuration","name":"environment-variable-interpolation-in-configuration","description":"Supports ${ENV_VAR} syntax in JSON configuration files to reference sensitive values stored in .env files. The extension loads .env from project root using dotenv parsing, then interpolates ${VARIABLE_NAME} placeholders in the JSON config (for database passwords, ChatGPT API keys, etc.). This allows committing non-sensitive config to version control while keeping secrets in .env (which is typically .gitignored).","intents":["Store database passwords and API keys securely in .env instead of committing them to version control","Use the same JSON config file across development, staging, and production by varying .env values","Avoid hardcoding credentials in configuration while maintaining readable config structure"],"best_for":["Teams following 12-factor app principles with environment-based configuration","Projects with multiple deployment environments (dev, staging, prod) sharing the same config template","Security-conscious developers who want to keep secrets out of version control"],"limitations":["Only reads .env from project root — no support for .env.local, .env.production, or environment-specific overrides","Interpolation is simple string replacement — no type coercion or validation of interpolated values","No built-in encryption of .env file — relies on .gitignore and file system permissions for security","Interpolation syntax is custom (${VAR_NAME}) — not compatible with standard shell or Docker env var syntax","No fallback or default values if environment variable is missing — will likely cause generation failure with unclear error message"],"requires":[".env file in project root with key=value pairs","dotenv library (version unspecified) for parsing .env format","JSON config file with ${VAR_NAME} placeholders in database.password and useAI.apiKey fields"],"input_types":["dotenv-file (.env with KEY=VALUE format)","json-configuration (with ${VAR_NAME} placeholders)"],"output_types":["interpolated-configuration (JSON with ${VAR_NAME} replaced by .env values)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_4","uri":"capability://code.generation.editing.postgresql.schema.aware.generation","name":"postgresql-schema-aware-generation","description":"Adds PostgreSQL-specific schema support by allowing explicit schema specification via the database.schema parameter (defaults to 'public'). The extension introspects tables, relationships, and constraints within the specified schema rather than the entire database. This enables multi-schema PostgreSQL databases to generate code for specific schemas without polluting the output with unrelated tables.","intents":["Generate code from a specific PostgreSQL schema in a multi-schema database","Isolate code generation to a logical schema (e.g., 'public' for application tables, 'audit' for audit tables)","Support PostgreSQL's schema isolation without generating code for all schemas"],"best_for":["PostgreSQL users with multi-schema database designs","Teams using schema-based access control or logical data separation in PostgreSQL"],"limitations":["Schema parameter is ignored for MySQL and MariaDB — no equivalent multi-schema support for those databases","Only one schema can be generated at a time — requires multiple configuration runs to generate code for multiple schemas","No schema-aware naming in generated code — generated classes don't reflect schema name, only table name"],"requires":["PostgreSQL database connection","database.schema parameter in JSON config (defaults to 'public' if omitted)","Read access to pg_tables or information_schema in the specified schema"],"input_types":["database-schema-parameter (string like 'public', 'audit', 'staging')","postgresql-schema-metadata (introspected from information_schema)"],"output_types":["schema-specific-code (generated code for tables in specified schema only)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_5","uri":"capability://data.processing.analysis.many.to.many.relationship.detection.via.naming.convention","name":"many-to-many-relationship-detection-via-naming-convention","description":"Detects many-to-many relationships by identifying pivot/junction tables based on a configurable naming convention separator (default: '_has_'). The extension scans the database schema for tables matching the pattern 'table1_has_table2' and generates appropriate relationship code (e.g., Doctrine ManyToMany associations) instead of treating them as standalone tables. The separator is configurable via database.many_to_many_sep parameter.","intents":["Automatically recognize many-to-many relationships from pivot table naming conventions","Generate proper ORM relationship code (ManyToMany associations) instead of separate model classes for junction tables","Support custom naming conventions for pivot tables (e.g., '_to_', '_join_') via configuration"],"best_for":["Projects using standard pivot table naming conventions (table1_has_table2, table1_to_table2, etc.)","Teams with consistent database design patterns where pivot tables follow predictable names"],"limitations":["Depends entirely on naming convention — non-standard pivot table names (e.g., 'user_role_mapping', 'article_tag_association') will not be recognized as many-to-many relationships","No semantic analysis of foreign keys — relies only on table name pattern matching, not constraint analysis","Single separator per configuration — cannot support multiple naming conventions simultaneously (e.g., both '_has_' and '_to_')","No way to manually override or hint at many-to-many relationships — purely convention-based","Generated relationship code assumes standard pivot table structure (only foreign keys, no additional columns) — fails for rich junction tables with extra data"],"requires":["database.many_to_many_sep parameter in JSON config (defaults to '_has_')","Pivot tables following the configured naming convention (e.g., 'users_has_roles' for default separator)","Pivot tables containing only foreign key columns (no additional data columns)"],"input_types":["database-schema (table names and foreign key constraints)","naming-convention-separator (string like '_has_', '_to_', '_join_')"],"output_types":["relationship-code (ORM-specific many-to-many association definitions)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_6","uri":"capability://tool.use.integration.vs.code.native.extension.integration","name":"vs-code-native-extension-integration","description":"Integrates as a native VS Code extension installed via the marketplace, providing direct access to the editor's file system, configuration, and UI. The extension reads project files (.env, JSON config) from the workspace root, writes generated code to the configured out_folder, and operates within VS Code's extension sandbox. Trigger mechanism (command palette, context menu, keybindings) is not documented.","intents":["Run code generation without leaving VS Code or opening external tools","Access project files and configuration directly from the editor workspace","Integrate code generation into the development workflow as a native editor command"],"best_for":["VS Code users who want to avoid context switching to CLI tools or external generators","Teams standardized on VS Code as the primary development environment","Developers who prefer IDE-integrated workflows over command-line tools"],"limitations":["Trigger mechanism is undocumented — unclear whether generation is invoked via command palette, context menu, keybinding, or other mechanism","Minimum VS Code version is unknown — documentation states 'You will need at least:' but does not specify version","File system access is limited to project root (.env location) and configured out_folder — cannot access files outside workspace","No documented keybindings or command names — users must discover trigger mechanism through trial or missing documentation","Extension runs in VS Code's sandbox — cannot execute arbitrary shell commands or access system resources beyond file I/O","No background/async processing documented — unclear if generation blocks VS Code UI during processing"],"requires":["Visual Studio Code (minimum version unknown)","Extension installed from VS Code marketplace","Project workspace open in VS Code with .env and JSON config files in root"],"input_types":["vs-code-workspace (project files and configuration)","editor-context (current file, selection, workspace root)"],"output_types":["generated-files (written to out_folder in workspace)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_7","uri":"capability://code.generation.editing.batch.multi.file.code.generation.with.output.directory","name":"batch-multi-file-code-generation-with-output-directory","description":"Generates multiple code files (models, repositories, services, controllers) in a single batch operation and writes them to a configured output directory (out_folder). The extension processes the entire database schema in one invocation, creating all necessary files according to the selected processors, rather than generating code file-by-file. Output directory is configurable via out_folder parameter and must be writable.","intents":["Generate a complete project structure (models, repositories, services, controllers) in one operation","Scaffold multiple related code files that depend on each other without manual coordination","Organize generated code in a dedicated output directory separate from hand-written code"],"best_for":["Developers bootstrapping new projects who need complete scaffolding in one step","Teams using code generation as a project initialization step rather than incremental updates","Projects with clear separation between generated and hand-written code"],"limitations":["All-or-nothing generation — cannot selectively generate only certain file types or tables","No incremental updates — re-running generation overwrites all output files, losing any manual modifications","Output directory must be empty or pre-existing — no merge or conflict resolution with existing files","No dependency ordering — generated files may have import/reference issues if processors don't account for generation order","Single output directory for all generated files — cannot organize by file type (models/ vs repositories/) without post-processing"],"requires":["out_folder parameter in JSON config specifying output directory path (e.g., './out')","Write permissions to out_folder directory","out_folder directory must exist or be creatable by the extension"],"input_types":["database-schema (entire schema introspected in one pass)","processor-configuration (array of processors to apply)"],"output_types":["multiple-source-files (models, repositories, services, controllers written to out_folder)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_8","uri":"capability://tool.use.integration.database.connection.configuration.with.credential.management","name":"database-connection-configuration-with-credential-management","description":"Manages database connections via JSON configuration with support for multiple database types (MySQL, MariaDB, PostgreSQL). Connection parameters (host, port, user, password, database, schema) are specified in JSON config with password values interpolated from .env file using ${ENV_VAR} syntax. The extension establishes connections to read schema metadata without exposing credentials in version control.","intents":["Configure database connections for schema introspection without hardcoding credentials","Support multiple database types (MySQL, MariaDB, PostgreSQL) with type-specific parameters","Use environment-specific database connections by varying .env values"],"best_for":["Teams with multiple database environments (dev, staging, prod) sharing the same config template","Projects following 12-factor app configuration principles","Developers who want to avoid committing database credentials to version control"],"limitations":["Only supports MySQL, MariaDB, and PostgreSQL — no support for SQLite, MongoDB, or other databases","Connection pooling and timeout parameters are not configurable — uses default connection settings","No connection validation or health checks — unclear if connection errors are reported clearly","Password must be in .env file — no support for other secret management systems (AWS Secrets Manager, HashiCorp Vault, etc.)","Single database connection per configuration — cannot generate code from multiple databases in one run","No support for SSL/TLS connection parameters — unclear if encrypted connections are supported"],"requires":["db_type parameter in JSON config (mysql, mariadb, or postgresql)","database.host, database.user, database.port, database.database parameters","database.password parameter with ${ENV_VAR} interpolation to .env file","database.schema parameter for PostgreSQL (defaults to 'public', ignored for MySQL/MariaDB)","Active database server running and accessible from the development machine","Network connectivity to database host and port"],"input_types":["json-configuration (db_type, host, port, user, database, schema)","environment-variables (password from .env)"],"output_types":["database-connection (established connection for schema introspection)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-marcflausino-codigo-generator__cap_9","uri":"capability://code.generation.editing.processor.based.code.generation.pipeline","name":"processor-based-code-generation-pipeline","description":"Implements code generation as a pipeline of named processors, where each processor is responsible for generating a specific artifact type (entity, repository, service, controller) for a specific framework. The extension reads a processors array from JSON config, applies each processor to the database schema, and produces framework-specific code. Processors are framework-aware (e.g., doctrine_entity knows Doctrine syntax) and can optionally support AI enhancement.","intents":["Generate different artifact types (models, repositories, services) using specialized processors","Support framework-specific code generation without monolithic generator logic","Enable selective code generation by choosing which processors to apply","Allow framework-specific customization per artifact type"],"best_for":["Developers who want fine-grained control over which code artifacts are generated","Teams using multiple frameworks who need processor-based customization","Projects where some artifact types should be generated while others are hand-written"],"limitations":["Processor list is incomplete — documentation references 'list below for supported frameworks and integrations' but list is truncated","No documentation on processor architecture or how to create custom processors — extension mechanism is unclear","AI support is processor-dependent — documentation states 'Check for AI column on processors list' but list is incomplete","Processors are applied sequentially without dependency management — unclear if processors can depend on output of previous processors","No processor configuration or parameterization — processors are selected by name only, no per-processor options"],"requires":["processors array in JSON config with processor names (e.g., ['doctrine_entity', 'doctrine_repository'])","Framework-specific processors available for the selected template (e.g., Doctrine processors for PHP template)","Database schema compatible with processor expectations (e.g., many-to-many processors expect pivot table naming convention)"],"input_types":["processor-names (array of strings like 'doctrine_entity', 'doctrine_repository')","database-schema (introspected from database)","template-context (framework/language information)"],"output_types":["framework-specific-code (output of each processor, e.g., Doctrine entity classes, repository classes)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Visual Studio Code (minimum version unknown — documentation incomplete)","Active database connection to MySQL, MariaDB, or PostgreSQL with read access to schema metadata",".env file in project root with database credentials (host, user, password, port, database name)","JSON configuration file specifying db_type, database connection details, template/framework, packageBaseName, and out_folder","Write permissions to the configured out_folder directory","useAI.enabled: true in JSON configuration","Valid OpenAI ChatGPT API key (stored in .env and referenced via ${CHATGPT_APIKEY} in config)","Active OpenAI account with API credits","Processor that supports AI enhancement (varies by framework/language)","packageBaseName parameter in JSON config (e.g., 'com.example.app', 'App\\Generated', 'app.models')"],"failure_modes":["Supports only MySQL, MariaDB, and PostgreSQL — no support for NoSQL, SQLite, or other relational databases","Language/framework support is incomplete and evolving ('hopefully more to come') — only TypeScript, PHP, Java, Python, C# documented","Many-to-many relationship detection depends on naming convention (configurable separator like '_has_') — non-standard pivot table names may not be recognized","No built-in support for custom code generation templates — limited to predefined processors per framework","Generated code is boilerplate only — does not include business logic, validation rules, or domain-specific patterns","AI enhancement is optional and processor-dependent — not all code generators support it (documentation incomplete on which processors have AI support)","Significantly increases processing time — no quantified timing data provided, but documented as material performance impact","Requires valid ChatGPT API key and active OpenAI account — adds per-request costs to generation workflow","No control over AI enhancement parameters (temperature, max tokens, system prompts) — all-or-nothing feature","AI output quality depends on ChatGPT's understanding of generated code context — may produce inconsistent or incorrect enhancements","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.11,"quality":0.32,"ecosystem":0.35000000000000003,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:34.803Z","last_scraped_at":"2026-05-03T15:20:31.090Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=codigo-generator","compare_url":"https://unfragile.ai/compare?artifact=codigo-generator"}},"signature":"C6+jITo62N1W1Lqc6kdxh61wGEQXdL+UUV1YpyI5nu3/60O9vAKGQgjrSzAnAGaxQGvjGiR0JvubEchNc1KkAA==","signedAt":"2026-06-21T12:39:57.907Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/codigo-generator","artifact":"https://unfragile.ai/codigo-generator","verify":"https://unfragile.ai/api/v1/verify?slug=codigo-generator","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}