{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-postgresml--postgresml","slug":"postgresml--postgresml","name":"postgresml","type":"mcp","url":"https://postgresml.org","page_url":"https://unfragile.ai/postgresml--postgresml","categories":["mcp-servers"],"tags":["ai","ann","approximate-nearest-neighbor-search","artificial-intelligence","classification","clustering","embeddings","forecasting","knn","llm","machine-learning","ml","postgres","rag","regression","sql","vector-database"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-postgresml--postgresml__cap_0","uri":"capability://data.processing.analysis.in.database.supervised.model.training.with.multi.framework.support","name":"in-database supervised model training with multi-framework support","description":"Trains classification and regression models directly within PostgreSQL using pgml.train() SQL function, with bindings to scikit-learn, XGBoost, and LightGBM via pyo3 Python integration layer. Models are persisted in the database as versioned artifacts with automatic hyperparameter tuning and cross-validation, eliminating data movement between application and model servers. The extension uses Rust's pgrx framework to expose these ML operations as native SQL functions that execute within the PostgreSQL process.","intents":["Train classification models on tabular data without exporting from the database","Manage multiple model versions and compare their performance metrics within SQL","Automate hyperparameter tuning and model selection as part of a data pipeline","Deploy trained models for inference with sub-millisecond latency on live data"],"best_for":["Data teams building feature stores in PostgreSQL","Applications requiring ACID-guaranteed predictions on transactional data","Organizations avoiding data exfiltration for compliance reasons"],"limitations":["Limited to tabular/structured data — no native image or audio training","Hyperparameter search space is predefined per algorithm; custom tuning requires SQL-level extension","Training on very large datasets (>100GB) may require careful memory management and batching","No distributed training across multiple PostgreSQL instances — single-node only"],"requires":["PostgreSQL 12+","Python 3.8+ installed on the PostgreSQL host","scikit-learn, xgboost, or lightgbm Python packages","Sufficient GPU memory if using GPU-accelerated training (optional)"],"input_types":["SQL table or view with numeric/categorical features","CSV or Parquet files imported into PostgreSQL tables"],"output_types":["Trained model artifact stored in pgml.models table","Model metadata: accuracy, precision, recall, F1, RMSE, MAE","Feature importance rankings"],"categories":["data-processing-analysis","ml-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_1","uri":"capability://memory.knowledge.gpu.accelerated.embedding.generation.and.semantic.search","name":"gpu-accelerated embedding generation and semantic search","description":"Generates dense vector embeddings from text using transformer models (BERT, Sentence Transformers, etc.) via pgml.embed() SQL function, with GPU acceleration when available. Embeddings are stored as native PostgreSQL vector columns and indexed using approximate nearest neighbor (ANN) algorithms (HNSW, IVFFlat) for sub-millisecond semantic search. The system uses the Hugging Face Transformers library via pyo3 bindings to load and execute models in-process, avoiding serialization overhead.","intents":["Generate embeddings for documents/text at scale without leaving the database","Build semantic search on top of existing PostgreSQL tables using vector similarity","Implement RAG pipelines by combining embeddings with LLM calls","Find similar items (products, documents, users) using cosine/L2 distance queries"],"best_for":["Teams building semantic search into existing PostgreSQL applications","RAG systems requiring low-latency retrieval of relevant context","E-commerce and content platforms needing similarity-based recommendations"],"limitations":["Embedding generation is single-threaded per query — batch operations recommended for throughput","Large embedding models (>1GB) may cause memory pressure on shared PostgreSQL instances","Vector index creation is blocking — requires downtime for very large tables (>10M rows)","No built-in support for sparse embeddings or multi-modal embeddings (image+text)"],"requires":["PostgreSQL 12+ with pgvector extension installed","Python 3.8+ with transformers library","GPU (CUDA 11.8+) for acceleration; CPU fallback available but slower","Sufficient disk space for model weights (typically 300MB–2GB per model)"],"input_types":["Text strings (up to 512 tokens for most models)","SQL query results (batched embedding of table columns)"],"output_types":["Dense vectors (768–1536 dimensions depending on model)","Similarity scores (cosine, L2 distance) from ANN queries","Ranked result sets ordered by semantic relevance"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_10","uri":"capability://data.processing.analysis.data.preprocessing.and.feature.engineering.within.sql","name":"data preprocessing and feature engineering within sql","description":"Provides SQL functions for common data preprocessing tasks (normalization, encoding, imputation, feature scaling) that execute within PostgreSQL. These functions operate on table columns and return transformed data that can be directly used for model training. The system supports both numeric and categorical transformations, with parameters stored for consistent application during inference.","intents":["Normalize and scale features for model training without exporting data","Encode categorical variables (one-hot, label encoding) in SQL","Handle missing values and outliers as part of the data pipeline","Apply consistent preprocessing during both training and inference"],"best_for":["Data teams building feature pipelines in PostgreSQL","Organizations avoiding data movement for compliance","ML systems requiring reproducible preprocessing"],"limitations":["Limited to built-in transformations; custom preprocessing requires SQL-level extension","Preprocessing parameters must be manually tracked for inference consistency","No automatic feature engineering (e.g., polynomial features, interactions)","Performance degrades on very large tables (>1B rows) without careful indexing"],"requires":["PostgreSQL 12+","pgml extension installed","Data in PostgreSQL tables"],"input_types":["SQL table columns with numeric or categorical data"],"output_types":["Transformed table columns ready for model training","Preprocessing metadata (scaling parameters, encoding mappings)"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_11","uri":"capability://data.processing.analysis.multi.model.ensemble.and.stacking.for.improved.predictions","name":"multi-model ensemble and stacking for improved predictions","description":"Combines predictions from multiple trained models using ensemble methods (voting, averaging, stacking) via SQL functions. The system trains meta-models that learn optimal weighting of base model predictions, improving overall accuracy. Ensemble predictions are executed as a single SQL query that calls multiple model inference functions and combines results according to the ensemble strategy.","intents":["Improve prediction accuracy by combining multiple models","Implement voting ensembles for classification tasks","Use stacking to learn optimal model combination weights","Compare ensemble vs. single-model performance"],"best_for":["High-stakes prediction systems requiring maximum accuracy","Teams with multiple trained models wanting to leverage all of them","Applications where ensemble overhead is acceptable"],"limitations":["Ensemble inference latency is sum of all base model latencies; no parallelization","Stacking requires careful train/validation split to avoid overfitting","No automatic ensemble architecture search; manual configuration required","Limited to models trained within PostgresML"],"requires":["PostgreSQL 12+ with pgml extension","Multiple trained models deployed","Sufficient compute for parallel inference (optional)"],"input_types":["Input features for prediction","Ensemble strategy (voting, averaging, stacking)"],"output_types":["Ensemble prediction (class label or probability)","Individual model predictions (for debugging)","Confidence scores"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_12","uri":"capability://data.processing.analysis.time.series.forecasting.with.temporal.models","name":"time-series forecasting with temporal models","description":"Trains and deploys time-series forecasting models (ARIMA, exponential smoothing, neural networks) using pgml.train() with time-series-specific algorithms. Models learn temporal patterns and seasonality from historical data, then generate future predictions. The system handles time-indexed data, lag features, and rolling window validation automatically. Predictions include confidence intervals for uncertainty quantification.","intents":["Forecast future values (sales, traffic, resource usage) from historical time-series data","Detect anomalies by comparing actual vs. predicted values","Generate confidence intervals for uncertainty-aware planning","Retrain models on new data without manual feature engineering"],"best_for":["Operations teams forecasting resource demand","Finance teams predicting revenue or market trends","Anomaly detection systems for monitoring"],"limitations":["Forecasting accuracy degrades for long horizons (>30 days) without external features","No automatic seasonality detection; requires manual configuration","Limited to univariate forecasting; multivariate models require custom implementation","Retraining on new data can be slow for very long time-series (>1M points)"],"requires":["PostgreSQL 12+ with pgml extension","Time-indexed data in PostgreSQL (timestamp column)","Sufficient historical data (typically >100 points)"],"input_types":["Time-series table with timestamp and value columns","Forecast horizon (number of future periods)"],"output_types":["Predicted values for future time periods","Confidence intervals (lower, upper bounds)","Model performance metrics (RMSE, MAE, MAPE)"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_2","uri":"capability://data.processing.analysis.text.chunking.and.preprocessing.for.rag.pipelines","name":"text chunking and preprocessing for rag pipelines","description":"Splits long documents into semantically coherent chunks using pgml.chunk() SQL function with configurable strategies (sliding window, sentence-aware, paragraph-aware). Chunks are stored with metadata (source, offset, chunk_id) and can be directly embedded and indexed for RAG retrieval. The function handles overlapping windows to preserve context across chunk boundaries and supports multiple languages via language-specific tokenizers.","intents":["Prepare documents for embedding by splitting into optimal chunk sizes","Maintain chunk-to-source traceability for citation and retrieval augmentation","Handle overlapping chunks to preserve semantic context across boundaries","Batch process large document collections without leaving PostgreSQL"],"best_for":["RAG system builders preparing documents for semantic search","Document processing pipelines that need to stay within PostgreSQL","Teams building question-answering systems over large document corpora"],"limitations":["No semantic-aware chunking (e.g., splitting at topic boundaries) — uses heuristic strategies only","Chunk size optimization is manual; no automatic tuning based on downstream embedding model","Limited language support — primarily English; other languages require custom tokenizer configuration","No built-in deduplication of overlapping chunks across multiple documents"],"requires":["PostgreSQL 12+","pgml extension installed","Text data in PostgreSQL table or imported as strings"],"input_types":["Long-form text (documents, articles, books)","SQL query results containing text columns"],"output_types":["Table of chunks with columns: chunk_id, text, source, offset, metadata","Ready for downstream embedding and indexing"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_3","uri":"capability://search.retrieval.vector.similarity.search.with.approximate.nearest.neighbor.indexing","name":"vector similarity search with approximate nearest neighbor indexing","description":"Performs semantic search using pgvector's native vector type combined with HNSW (Hierarchical Navigable Small World) or IVFFlat approximate nearest neighbor indexes. Queries use cosine similarity, L2 distance, or inner product operators to find k-nearest neighbors in sub-millisecond time. The system automatically manages index creation and tuning parameters (ef_construction, ef_search for HNSW; lists, probes for IVFFlat) based on dataset size.","intents":["Find semantically similar documents/items using vector similarity","Implement k-NN retrieval for RAG context augmentation","Build recommendation systems based on embedding similarity","Perform reverse image/text search by comparing embeddings"],"best_for":["Applications requiring sub-100ms semantic search on millions of vectors","RAG systems needing fast context retrieval during LLM inference","Recommendation engines built on top of PostgreSQL"],"limitations":["ANN indexes trade recall for speed — approximate results, not exact k-NN","Index creation is blocking and memory-intensive for >50M vectors","No support for filtered ANN (e.g., 'find similar items in category X') without post-filtering","HNSW index size grows with dataset size; very large indexes (>100GB) may exceed available RAM"],"requires":["PostgreSQL 12+ with pgvector extension","Vector column created with vector type (e.g., vector(768))","Sufficient RAM for index (typically 10–20x the vector data size)"],"input_types":["Query vector (768–1536 dimensions)","Distance metric (cosine, L2, inner product)"],"output_types":["Ranked list of k nearest neighbors with similarity scores","Row IDs and associated metadata from original table"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_4","uri":"capability://text.generation.language.llm.inference.via.openai.compatible.api.endpoint","name":"llm inference via openai-compatible api endpoint","description":"Exposes PostgresML as an OpenAI-compatible LLM API server, allowing any client using OpenAI SDK to query models hosted in PostgreSQL. The system supports streaming responses, function calling, and chat completions. Models can be deployed from Hugging Face or custom fine-tuned models, with inference executed on GPU when available. The API layer handles tokenization, prompt formatting, and response streaming without requiring application-level integration changes.","intents":["Use PostgresML models as a drop-in replacement for OpenAI API in existing applications","Build RAG systems that combine semantic search with local LLM inference","Deploy fine-tuned models without managing separate inference servers","Stream LLM responses directly to clients with low latency"],"best_for":["Teams wanting to replace cloud LLM APIs with self-hosted models","RAG systems combining PostgreSQL retrieval with local inference","Applications requiring low-latency LLM responses with data residency requirements"],"limitations":["Inference speed depends on GPU availability; CPU inference is slow (5–50 tokens/sec)","Large models (>7B parameters) require significant VRAM; quantization recommended","No built-in load balancing across multiple PostgreSQL instances","Streaming responses add latency overhead compared to batch inference","Limited to models available on Hugging Face or custom fine-tuned models"],"requires":["PostgreSQL 12+ with pgml extension","GPU with sufficient VRAM for model (e.g., 16GB for 7B-parameter model)","OpenAI Python SDK or compatible HTTP client","Model weights downloaded from Hugging Face (one-time, ~2–50GB)"],"input_types":["Chat messages (system, user, assistant roles)","Prompt text","Function definitions for function calling"],"output_types":["Chat completion responses (streaming or batch)","Function call arguments","Token usage statistics"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_5","uri":"capability://text.generation.language.transformer.based.nlp.task.execution.classification.ner.q.a","name":"transformer-based nlp task execution (classification, ner, q&a)","description":"Executes pre-trained transformer models for NLP tasks (text classification, named entity recognition, question answering, summarization) via pgml.transform() SQL function. Models are loaded from Hugging Face and executed with GPU acceleration. Results are returned as structured data (labels, scores, entities, answers) that can be directly stored in PostgreSQL tables or used in downstream SQL queries. The system handles tokenization, batching, and result formatting automatically.","intents":["Classify documents or text at scale without leaving the database","Extract named entities from unstructured text for data enrichment","Answer questions over document collections using QA models","Summarize long documents as part of a data pipeline"],"best_for":["Content moderation and classification pipelines","Data enrichment workflows that need NLP without external services","Question-answering systems over document collections"],"limitations":["Task-specific models required; no single model handles all NLP tasks","Inference latency scales with text length; very long documents may timeout","No fine-tuning support — only inference on pre-trained models","Limited to models available on Hugging Face; custom models require manual loading"],"requires":["PostgreSQL 12+ with pgml extension","Python 3.8+ with transformers library","GPU for reasonable inference speed (optional but recommended)","Model weights downloaded from Hugging Face"],"input_types":["Text strings (documents, sentences, paragraphs)","SQL query results containing text columns"],"output_types":["Classification labels with confidence scores","Named entities with types and positions","Question-answer pairs","Summarized text"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_6","uri":"capability://automation.workflow.model.versioning.and.lifecycle.management.with.deployment.tracking","name":"model versioning and lifecycle management with deployment tracking","description":"Manages trained model artifacts as versioned database objects with automatic tracking of training parameters, metrics, and deployment status. The pgml.deploy() function activates a specific model version for production inference, while pgml.models and pgml.deployments tables maintain audit trails. Models are stored as serialized objects in the database with metadata (algorithm, hyperparameters, training date, performance metrics), enabling rollback and A/B testing of different versions.","intents":["Track multiple versions of trained models and compare their performance","Deploy new model versions without downtime using atomic version switching","Audit which model version made a prediction for compliance/debugging","Rollback to previous model versions if new versions underperform"],"best_for":["ML teams managing model governance and compliance","Production systems requiring model versioning and rollback capability","Organizations needing audit trails for model predictions"],"limitations":["No built-in A/B testing framework — requires manual query logic to route traffic","Model storage in database can consume significant disk space for large models","No automatic retraining triggers — requires external orchestration","Limited to models trained within PostgresML; external models require manual import"],"requires":["PostgreSQL 12+","pgml extension installed","Sufficient disk space for model artifacts (typically 100MB–2GB per model)"],"input_types":["Trained model objects from pgml.train()","Model metadata and deployment parameters"],"output_types":["Model registry with version history","Deployment audit trail","Performance metrics per version"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_7","uri":"capability://tool.use.integration.korvus.sdk.for.programmatic.model.training.and.inference","name":"korvus sdk for programmatic model training and inference","description":"Provides a Python SDK (Korvus) that wraps PostgresML SQL functions with a high-level API for training, inference, and RAG pipeline construction. The SDK handles connection pooling, error handling, and result marshaling, allowing Python developers to build ML workflows without writing SQL. It supports both synchronous and asynchronous operations and integrates with LangChain for RAG applications.","intents":["Build ML workflows in Python without writing SQL","Integrate PostgresML into existing Python applications and frameworks","Construct RAG pipelines combining retrieval and generation","Manage model training and deployment from Python code"],"best_for":["Python developers building ML applications","Teams using LangChain or other Python ML frameworks","Rapid prototyping of ML pipelines"],"limitations":["SDK abstractions add ~50–200ms latency per operation compared to direct SQL","Async operations require careful error handling; connection pool exhaustion possible under load","Limited to operations exposed in the SDK; advanced SQL features require raw SQL fallback","Documentation and examples lag behind SQL API"],"requires":["Python 3.8+","Korvus package installed (pip install korvus)","PostgreSQL 12+ with pgml extension","Valid PostgreSQL connection string"],"input_types":["Python data structures (lists, dicts, DataFrames)","SQL connection parameters"],"output_types":["Python objects (trained models, predictions, embeddings)","Pandas DataFrames"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_8","uri":"capability://automation.workflow.dashboard.and.web.ui.for.model.management.and.monitoring","name":"dashboard and web ui for model management and monitoring","description":"Provides a web-based dashboard (pgml-dashboard) for visualizing trained models, monitoring inference performance, and managing deployments. The dashboard displays model metrics, training history, prediction latency, and resource usage. It includes a SQL editor for running queries and a model registry interface for version management. Built with React and TypeScript, it connects to PostgreSQL via a REST API layer.","intents":["Monitor model performance and inference latency in production","Visualize training metrics and compare model versions","Manage model deployments and rollbacks through a UI","Execute SQL queries and explore data without command-line tools"],"best_for":["Non-technical stakeholders monitoring model performance","ML teams managing multiple models and deployments","Organizations requiring audit trails and compliance dashboards"],"limitations":["Dashboard is read-mostly; advanced operations still require SQL","Real-time monitoring has ~5–10 second latency due to polling","No built-in alerting or anomaly detection","Limited customization without modifying source code"],"requires":["PostgreSQL 12+ with pgml extension","Node.js 16+ (if self-hosting dashboard)","Web browser with modern JavaScript support"],"input_types":["PostgreSQL connection parameters","Model and deployment metadata from pgml tables"],"output_types":["HTML/CSS/JavaScript UI","JSON API responses","Performance metrics and visualizations"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-postgresml--postgresml__cap_9","uri":"capability://planning.reasoning.end.to.end.rag.pipeline.construction.with.retrieval.and.generation","name":"end-to-end rag pipeline construction with retrieval and generation","description":"Combines embedding generation, vector search, and LLM inference into a cohesive RAG pipeline within PostgreSQL. The system orchestrates document chunking, embedding, indexing, and retrieval in a single transaction, then passes retrieved context to an LLM for generation. The Korvus SDK provides high-level abstractions for RAG workflows, while raw SQL allows fine-grained control. Results include both retrieved documents and generated responses with source attribution.","intents":["Build question-answering systems over document collections","Implement retrieval-augmented generation without external services","Combine semantic search with LLM inference in a single pipeline","Generate responses with source attribution for citations"],"best_for":["Teams building Q&A systems over proprietary documents","Organizations requiring data residency (no external APIs)","Applications needing low-latency retrieval + generation"],"limitations":["Pipeline latency is sum of retrieval + generation time; no parallelization","Retrieved context is limited by LLM context window; long documents may be truncated","No built-in prompt optimization or chain-of-thought reasoning","Quality depends on embedding model and retrieval ranking; no automatic prompt tuning"],"requires":["PostgreSQL 12+ with pgml extension and pgvector","Documents imported and chunked in PostgreSQL","Embeddings generated and indexed","LLM model deployed (local or via OpenAI API)"],"input_types":["User query (text string)","Document collection (in PostgreSQL)","Retrieval parameters (k, similarity threshold)"],"output_types":["Generated response text","Retrieved source documents with relevance scores","Source attribution metadata"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"high","permissions":["PostgreSQL 12+","Python 3.8+ installed on the PostgreSQL host","scikit-learn, xgboost, or lightgbm Python packages","Sufficient GPU memory if using GPU-accelerated training (optional)","PostgreSQL 12+ with pgvector extension installed","Python 3.8+ with transformers library","GPU (CUDA 11.8+) for acceleration; CPU fallback available but slower","Sufficient disk space for model weights (typically 300MB–2GB per model)","pgml extension installed","Data in PostgreSQL tables"],"failure_modes":["Limited to tabular/structured data — no native image or audio training","Hyperparameter search space is predefined per algorithm; custom tuning requires SQL-level extension","Training on very large datasets (>100GB) may require careful memory management and batching","No distributed training across multiple PostgreSQL instances — single-node only","Embedding generation is single-threaded per query — batch operations recommended for throughput","Large embedding models (>1GB) may cause memory pressure on shared PostgreSQL instances","Vector index creation is blocking — requires downtime for very large tables (>10M rows)","No built-in support for sparse embeddings or multi-modal embeddings (image+text)","Limited to built-in transformations; custom preprocessing requires SQL-level extension","Preprocessing parameters must be manually tracked for inference consistency","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6001673468795309,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.6,"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:22.063Z","last_scraped_at":"2026-05-03T13:58:32.037Z","last_commit":"2025-07-01T12:26:02Z"},"community":{"stars":6779,"forks":361,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=postgresml--postgresml","compare_url":"https://unfragile.ai/compare?artifact=postgresml--postgresml"}},"signature":"Hx1f9HcmdZLIVj48SaC+++TI2tV6QaK3EVvpbVe2QPuC+3OobVCNGdVgOvZoDACojh2rrz6mISz9iKflMBqNDA==","signedAt":"2026-06-20T14:46:52.990Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/postgresml--postgresml","artifact":"https://unfragile.ai/postgresml--postgresml","verify":"https://unfragile.ai/api/v1/verify?slug=postgresml--postgresml","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"}}