{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-integuru-ai--integuru","slug":"integuru-ai--integuru","name":"Integuru","type":"agent","url":"https://integuru.ai","page_url":"https://unfragile.ai/integuru-ai--integuru","categories":["automation"],"tags":["agent","agents","ai-agent","ai-agents","api","apis","automation","integration","integrations","llm","open-source","openapi","robotic-process-automation","rpa","unofficial-api","unofficial-apis"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-integuru-ai--integuru__cap_0","uri":"capability://data.processing.analysis.har.based.http.traffic.capture.and.session.recording","name":"har-based http traffic capture and session recording","description":"Automates browser-based HTTP traffic capture using Playwright-controlled Chromium, recording all network requests/responses in HAR (HTTP Archive) format alongside authentication cookies and session tokens. The system spawns a headless browser instance, allows manual user interaction including 2FA flows, and persists complete network logs with metadata for downstream LLM analysis. This approach captures real API calls as they occur in production web applications without requiring API documentation.","intents":["I need to record all API calls a web app makes when I perform a specific action, including authentication","I want to capture network traffic with cookies and session state for reverse engineering an undocumented API","I need to automate the process of recording browser interactions with 2FA-protected platforms"],"best_for":["developers reverse-engineering closed-source web platforms","integration builders working with platforms lacking public APIs","teams automating data extraction from SaaS tools"],"limitations":["Requires manual user interaction during capture phase — cannot fully automate 2FA flows","HAR files capture only HTTP layer — cannot record WebSocket, gRPC, or binary protocol traffic","Browser automation may be detected and blocked by anti-bot measures on target platforms","Session tokens captured in plaintext within HAR/cookies files — requires secure storage"],"requires":["Python 3.9+","Playwright library (handles Chromium installation)","Target platform accessible via standard HTTP/HTTPS","User credentials or session tokens for authenticated endpoints"],"input_types":["user interaction (manual clicks/form fills in browser)","authentication credentials","natural language description of target action"],"output_types":["HAR file (JSON format with all HTTP entries)","cookies.json (session tokens and auth cookies)","structured request/response metadata"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_1","uri":"capability://planning.reasoning.llm.powered.target.api.endpoint.identification.from.traffic.logs","name":"llm-powered target api endpoint identification from traffic logs","description":"Uses semantic LLM analysis to identify which HTTP request in a captured HAR file accomplishes the user's stated goal, without requiring prior knowledge of API structure. The system sends the HAR entries and a natural language prompt (e.g., 'create a new task') to an LLM, which analyzes request patterns, response structures, and semantics to pinpoint the primary action endpoint. This enables users to specify intent in plain English rather than manually locating the correct API call.","intents":["I performed an action in the web app — which API request actually did it?","I want the system to automatically find the main API call for my use case without me manually inspecting network logs","I need to distinguish between the primary action request and supporting/preflight requests"],"best_for":["non-technical users who cannot read HTTP logs","developers building integrations for complex multi-request workflows","teams automating API discovery for platforms with hundreds of endpoints"],"limitations":["LLM accuracy depends on clarity of user intent — ambiguous prompts may identify wrong endpoint","Cannot distinguish between semantically similar requests (e.g., two different 'create' endpoints)","Requires sufficient context in HAR file — sparse traffic logs reduce accuracy","LLM token costs scale with HAR file size (large traffic logs = expensive analysis)"],"requires":["HAR file with at least 5-10 relevant HTTP entries","Natural language description of the target action","LLM API access (OpenAI, Anthropic, or local model via LangChain)","Valid API credentials for chosen LLM provider"],"input_types":["HAR file (JSON)","natural language prompt describing desired action","optional: additional context about platform behavior"],"output_types":["identified HTTP request object (method, URL, headers, body)","confidence score or reasoning from LLM","request index within HAR file"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_10","uri":"capability://automation.workflow.authentication.and.session.state.preservation.across.request.sequences","name":"authentication and session state preservation across request sequences","description":"Captures and preserves authentication cookies, session tokens, and headers from the initial HAR capture, then applies them to generated code to maintain authenticated sessions across multi-step request sequences. Handles cookie expiration, token refresh patterns (when detectable from HAR), and header-based authentication (Bearer tokens, API keys). Enables generated code to execute without requiring users to manually manage authentication state.","intents":["I want generated code to automatically use the authentication from my captured session","I need to understand which cookies/tokens are required for each request","I want to handle session expiration and token refresh in generated code"],"best_for":["developers building authenticated API integrations","teams automating workflows for platforms requiring login","integration builders handling complex authentication schemes"],"limitations":["Captured cookies/tokens are time-limited — generated code may fail after session expiration","Cannot automatically detect token refresh patterns — requires manual implementation","Multi-factor authentication tokens cannot be captured — requires manual re-authentication","Sensitive credentials stored in HAR/generated code — requires secure handling","Some platforms detect and block requests from non-browser clients even with correct auth headers"],"requires":["HAR file captured with authenticated session","cookies.json file with session tokens","LLM access to identify auth-related headers and cookies"],"input_types":["HAR file with authenticated requests","cookies.json with session data","optional: authentication scheme hints (Bearer, Basic, custom)"],"output_types":["extracted authentication headers and cookies","generated code with auth headers applied","documentation of auth requirements"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_11","uri":"capability://code.generation.editing.request.body.and.parameter.template.generation.with.variable.substitution","name":"request body and parameter template generation with variable substitution","description":"Generates request body templates and parameter specifications for each request node in the dependency graph, identifying which fields are static vs dynamic and creating variable placeholders for dynamic values. Produces Python code with f-strings or format() calls for parameter substitution, enabling generated functions to accept dynamic values as arguments and construct proper request bodies. Handles JSON, form-encoded, and multipart request bodies.","intents":["I want generated code to accept parameters and substitute them into request bodies","I need to understand which request fields are static vs dynamic","I want to generate request templates that can be reused with different parameter values"],"best_for":["developers building parameterized API integrations","teams automating workflows with variable inputs","integration builders creating reusable request templates"],"limitations":["Cannot infer parameter types from HAR alone — generated code may require type hints","Complex nested JSON structures may produce hard-to-read templates","Multipart file uploads require special handling — may not generate correctly","URL encoding and escaping may be incorrect for special characters"],"requires":["identified dynamic parameters from parameter detection capability","request body samples from HAR file","LLM access for template inference"],"input_types":["request objects with identified dynamic fields","response data containing dynamic values","optional: parameter type hints"],"output_types":["request body templates (strings with placeholders)","parameter lists with inferred types","generated Python code with substitution logic"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_12","uri":"capability://data.processing.analysis.response.parsing.and.data.extraction.for.downstream.request.dependencies","name":"response parsing and data extraction for downstream request dependencies","description":"Analyzes HTTP response bodies from captured requests to identify and extract values that are used as parameters in downstream requests. Handles JSON, HTML, and form-encoded responses, using LLM semantic analysis to locate relevant data fields (IDs, tokens, URLs) within responses. Generates extraction code (JSON path, regex, or parsing logic) that can be applied to live API responses during execution.","intents":["I need to extract specific values from API responses to use in subsequent requests","I want to understand which response fields are used by downstream requests","I need generated code that can parse responses and extract required data"],"best_for":["developers building multi-step API workflows with data passing","teams automating complex business processes requiring data extraction","integration builders handling APIs with opaque response structures"],"limitations":["Cannot extract data from responses not captured in HAR — requires complete workflow capture","HTML parsing is fragile — page structure changes break extraction logic","JSON path extraction may be ambiguous if multiple fields match the pattern","Nested or deeply structured responses may produce complex extraction code"],"requires":["HAR file with complete request/response pairs","identified dynamic parameters and their sources","LLM access for semantic field identification"],"input_types":["response bodies (JSON, HTML, form-encoded)","identified dynamic parameters to extract","optional: field type hints or schema information"],"output_types":["extraction specifications (JSON path, regex, parsing logic)","generated Python code for response parsing","extracted sample values from captured responses"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_2","uri":"capability://data.processing.analysis.dynamic.parameter.detection.and.extraction.from.http.requests","name":"dynamic parameter detection and extraction from http requests","description":"Identifies which URL parameters, headers, request body fields, and cookies contain dynamic values (non-static data that varies between requests) using LLM semantic analysis. The system analyzes request patterns across the HAR file to detect fields that change between calls (e.g., user IDs, timestamps, CSRF tokens, pagination cursors) and marks them as dependencies requiring upstream resolution. This enables the system to distinguish between static configuration and values that must be sourced from other API responses.","intents":["I need to know which parts of an API request are hardcoded vs which parts change dynamically","I want to automatically identify which request parameters depend on data from other API calls","I need to find all the dynamic values in a request so I can trace where they come from"],"best_for":["developers building multi-step API workflows with data dependencies","integration builders automating complex user journeys with state passing","teams reverse-engineering APIs with opaque parameter semantics"],"limitations":["Cannot distinguish between truly dynamic values and coincidentally-similar static values without multiple request samples","May miss dynamic values that appear identical across captured requests (e.g., user ID if only one user was active during capture)","Requires sufficient request diversity in HAR file — single-request captures cannot detect patterns","LLM heuristics may misclassify base64-encoded or hashed values as static when they are actually dynamic"],"requires":["HAR file with multiple requests to the same or similar endpoints","LLM access for semantic analysis","At least 2-3 request samples per endpoint to detect variation patterns"],"input_types":["HTTP request objects (URL, headers, body, cookies)","multiple request samples for pattern comparison","optional: field type hints or schema information"],"output_types":["list of dynamic fields with locations (URL param, header, body field, cookie)","field value samples from captured requests","confidence scores for each dynamic field detection"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_3","uri":"capability://planning.reasoning.recursive.dependency.graph.construction.via.backward.har.tracing","name":"recursive dependency graph construction via backward har tracing","description":"Builds a directed acyclic graph (DAG) of API request dependencies by recursively tracing dynamic values backward through the HAR file to their source responses. For each dynamic parameter identified in the target request, the system searches earlier requests' responses to find where that value originated, then repeats the process for those upstream requests until reaching base requests that only require authentication cookies. Uses NetworkX for graph representation and topological ordering, enabling visualization and execution planning of the complete request chain.","intents":["I need to understand the complete chain of API calls required to accomplish my goal","I want to visualize which API requests depend on which other requests","I need to know the correct order to execute API calls to satisfy all data dependencies"],"best_for":["developers building multi-step integrations with complex data flows","teams analyzing API workflows to understand platform architecture","integration builders automating business processes with state passing"],"limitations":["Cannot detect dependencies across different sessions or browser tabs — requires single continuous HAR capture","May create false dependencies if response values coincidentally match parameter values from unrelated requests","Circular dependency detection is limited — complex state machines may not be fully resolvable","Large HAR files with 100+ requests may create exponentially complex graphs requiring optimization"],"requires":["HAR file with complete request/response history including response bodies","LLM access for semantic matching of values across requests","NetworkX library for graph construction and analysis","Target request identified (from endpoint identification capability)"],"input_types":["HAR file with full request/response data","target request object to trace dependencies for","optional: field type hints to improve matching accuracy"],"output_types":["NetworkX directed graph object with request nodes and dependency edges","topologically sorted list of requests in execution order","dependency tree visualization (JSON or graphviz format)","list of base requests (those with no upstream dependencies)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_4","uri":"capability://code.generation.editing.llm.driven.python.code.generation.from.dependency.graphs","name":"llm-driven python code generation from dependency graphs","description":"Converts the constructed dependency DAG into executable Python code by generating a function for each graph node with proper parameter passing and sequencing. The system uses LLM analysis to infer function signatures, handle authentication, manage session state, and implement error handling based on observed request patterns. Generated code includes type hints, docstrings, and proper async/await patterns where applicable, producing production-ready integration code that replicates the captured workflow.","intents":["I want to convert my captured API workflow into executable Python code I can use in my application","I need generated code that handles authentication, session management, and parameter passing automatically","I want to avoid manually writing boilerplate code for multi-step API integrations"],"best_for":["developers building Python-based integrations for undocumented APIs","teams automating data pipelines that require multi-step API workflows","rapid prototyping of integrations before official API documentation is available"],"limitations":["Generated code quality depends on HAR file completeness — missing requests or error cases may produce incomplete code","LLM may generate code with incorrect error handling or edge case logic","Cannot infer business logic beyond request sequencing — generated code is structural, not semantic","Async/await patterns may not match target application's concurrency model","Generated code requires manual review and testing before production use","No built-in support for rate limiting, retry logic, or circuit breakers — requires manual addition"],"requires":["Complete dependency DAG from graph construction capability","LLM access for code generation","Python 3.9+ target environment","requests or httpx library for HTTP calls (or async equivalents)"],"input_types":["NetworkX DAG object with request nodes","request metadata (method, URL, headers, body templates)","authentication information (cookies, tokens, headers)","optional: code style preferences or framework hints"],"output_types":["Python source code (.py file)","function definitions with type hints","docstrings and comments","optional: unit test stubs"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_5","uri":"capability://tool.use.integration.multi.provider.llm.orchestration.with.pluggable.model.support","name":"multi-provider llm orchestration with pluggable model support","description":"Provides abstraction layer for LLM interactions supporting multiple providers (OpenAI, Anthropic, local models via Ollama) through a unified interface. The system uses LangChain for provider abstraction, enabling users to swap LLM backends without code changes. Handles token counting, context window management, and provider-specific API differences transparently, allowing cost optimization and model selection based on task complexity.","intents":["I want to use different LLM providers (OpenAI, Anthropic, local) without rewriting analysis code","I need to optimize costs by using cheaper models for simple tasks and powerful models for complex analysis","I want to run Integuru offline using local models without cloud API dependencies"],"best_for":["teams with multi-cloud LLM strategies","organizations with data privacy requirements preferring local models","cost-conscious builders optimizing LLM spend across different task types"],"limitations":["Local model performance varies significantly — smaller models may fail on complex dependency analysis","Provider-specific features (vision, function calling) not uniformly supported across all backends","Token counting estimates may be inaccurate for some providers, causing context window overflows","Latency varies dramatically between providers — local models may be 10-100x slower than cloud APIs","No automatic fallback if primary provider fails — requires manual configuration"],"requires":["LangChain library","API keys for chosen provider (OpenAI, Anthropic) OR local Ollama instance","Python 3.9+","Network access to provider APIs (or local network for Ollama)"],"input_types":["LLM provider configuration (API key, model name, parameters)","prompts and context for analysis tasks","optional: token budget constraints"],"output_types":["LLM responses (text, structured JSON)","token usage metrics","provider-specific metadata"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_6","uri":"capability://automation.workflow.jupyter.notebook.based.interactive.analysis.and.code.inspection","name":"jupyter notebook-based interactive analysis and code inspection","description":"Provides Jupyter notebook interface for step-by-step HAR analysis, dependency graph visualization, and generated code inspection. Users can interactively explore captured requests, visualize the dependency DAG, inspect LLM reasoning at each step, and iteratively refine analysis parameters. Enables debugging of failed dependency detection and manual correction of misidentified relationships before code generation.","intents":["I want to visually inspect the dependency graph before generating code","I need to debug why the system misidentified a dependency or dynamic parameter","I want to manually correct or refine the analysis before code generation"],"best_for":["developers debugging complex API workflows","teams learning how Integuru analyzes dependencies","integration builders validating analysis accuracy before production use"],"limitations":["Jupyter interface requires local development environment — not suitable for CI/CD automation","Large HAR files may cause notebook performance degradation","Graph visualization limited to text/ASCII output without additional graphing libraries","Manual corrections are not persisted — require re-running analysis to apply changes"],"requires":["Jupyter notebook environment","Python 3.9+","Integuru library installed","HAR file and analysis results"],"input_types":["HAR file","analysis results (identified endpoints, dependencies)","optional: manual corrections or parameter overrides"],"output_types":["interactive notebook cells with analysis results","ASCII/text dependency graph visualization","generated Python code for inspection","LLM reasoning traces and confidence scores"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_7","uri":"capability://automation.workflow.command.line.interface.for.batch.har.analysis.and.code.generation","name":"command-line interface for batch har analysis and code generation","description":"Provides CLI entry point for automated, non-interactive HAR analysis and Python code generation suitable for CI/CD pipelines and batch processing. Accepts HAR files, configuration parameters, and natural language prompts via command-line arguments, producing generated code and analysis reports without requiring user interaction. Supports output to files, stdout, and optional JSON reports for integration with downstream tools.","intents":["I want to automate API reverse engineering in my CI/CD pipeline","I need to batch-process multiple HAR files and generate code for each","I want to integrate Integuru into my development workflow without manual steps"],"best_for":["DevOps teams automating integration code generation","organizations processing multiple APIs in batch","CI/CD pipelines requiring non-interactive analysis"],"limitations":["No interactive debugging or manual correction — analysis must be correct on first run","Error messages may be cryptic without Jupyter context for inspection","Large batch jobs may timeout if HAR files are very large","No progress indication for long-running analyses"],"requires":["Python 3.9+ with Integuru installed","HAR file(s) as input","LLM API credentials in environment variables or config file","Write permissions to output directory"],"input_types":["HAR file path(s)","natural language prompt describing target action","optional: configuration file (YAML/JSON) with analysis parameters","optional: output format specification"],"output_types":["generated Python code (.py file)","analysis report (JSON or text)","exit codes indicating success/failure","optional: dependency graph visualization (DOT format)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_8","uri":"capability://data.processing.analysis.har.file.parsing.and.http.request.response.normalization","name":"har file parsing and http request/response normalization","description":"Parses HAR files (JSON format) and normalizes HTTP request/response data into structured objects for downstream analysis. Handles HAR format variations, extracts relevant metadata (headers, cookies, body, timing), and validates data integrity. Provides utilities for filtering requests by criteria (URL patterns, methods, status codes) and accessing request/response pairs with proper association.","intents":["I need to load and parse a HAR file into structured data for analysis","I want to filter requests by URL pattern or HTTP method","I need to access request/response pairs with proper association"],"best_for":["developers building custom HAR analysis tools","teams processing HAR files from multiple sources","integration builders requiring flexible request filtering"],"limitations":["HAR format variations may cause parsing errors — requires validation","Large HAR files (100MB+) may cause memory issues","Binary response bodies are base64-encoded in HAR — decoding adds overhead","Timing information in HAR may be inaccurate for slow networks"],"requires":["Valid HAR file (JSON format)","Python 3.9+","json library (standard library)"],"input_types":["HAR file (JSON)","optional: filter criteria (URL patterns, methods, status codes)"],"output_types":["parsed request/response objects","filtered request lists","metadata and statistics about captured traffic"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-integuru-ai--integuru__cap_9","uri":"capability://automation.workflow.langgraph.based.workflow.orchestration.for.multi.step.analysis","name":"langgraph-based workflow orchestration for multi-step analysis","description":"Uses LangGraph's StateGraph pattern to orchestrate multi-step analysis workflow with explicit state management and conditional branching. Each analysis step (target identification, dynamic detection, dependency tracing, code generation) is a graph node with defined inputs/outputs and state transitions. Enables resumable analysis, step-by-step debugging, and conditional execution based on intermediate results.","intents":["I want to understand the analysis workflow and how steps connect","I need to resume analysis from a specific step without re-running earlier steps","I want to conditionally skip steps based on analysis results"],"best_for":["developers extending Integuru with custom analysis steps","teams requiring resumable/checkpointable analysis workflows","organizations building custom orchestration on top of Integuru"],"limitations":["LangGraph adds abstraction overhead — slightly slower than direct function calls","State serialization may be complex for large HAR files","Debugging graph execution requires understanding LangGraph patterns","Limited to Python ecosystem — no language-agnostic workflow definition"],"requires":["LangGraph library","Python 3.9+","Understanding of StateGraph pattern"],"input_types":["initial state (HAR file, prompt, configuration)","optional: checkpoint/resume state"],"output_types":["final analysis state with all results","intermediate states at each step","execution trace for debugging"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":49,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Playwright library (handles Chromium installation)","Target platform accessible via standard HTTP/HTTPS","User credentials or session tokens for authenticated endpoints","HAR file with at least 5-10 relevant HTTP entries","Natural language description of the target action","LLM API access (OpenAI, Anthropic, or local model via LangChain)","Valid API credentials for chosen LLM provider","HAR file captured with authenticated session","cookies.json file with session tokens"],"failure_modes":["Requires manual user interaction during capture phase — cannot fully automate 2FA flows","HAR files capture only HTTP layer — cannot record WebSocket, gRPC, or binary protocol traffic","Browser automation may be detected and blocked by anti-bot measures on target platforms","Session tokens captured in plaintext within HAR/cookies files — requires secure storage","LLM accuracy depends on clarity of user intent — ambiguous prompts may identify wrong endpoint","Cannot distinguish between semantically similar requests (e.g., two different 'create' endpoints)","Requires sufficient context in HAR file — sparse traffic logs reduce accuracy","LLM token costs scale with HAR file size (large traffic logs = expensive analysis)","Captured cookies/tokens are time-limited — generated code may fail after session expiration","Cannot automatically detect token refresh patterns — requires manual implementation","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5721461780003749,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"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:21.550Z","last_scraped_at":"2026-04-22T08:01:53.258Z","last_commit":"2026-04-15T19:28:32Z"},"community":{"stars":4572,"forks":359,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=integuru-ai--integuru","compare_url":"https://unfragile.ai/compare?artifact=integuru-ai--integuru"}},"signature":"uZWG+SgRc3Rde3gBf/U+v8Zebvb7ESc/gziKGjsqePM6XkG2iVDFNfEhpQEACfLchckpMUBYtuVwOA/oKRSLCA==","signedAt":"2026-06-22T10:37:46.816Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/integuru-ai--integuru","artifact":"https://unfragile.ai/integuru-ai--integuru","verify":"https://unfragile.ai/api/v1/verify?slug=integuru-ai--integuru","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"}}