{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-flagopen--flagembedding","slug":"flagopen--flagembedding","name":"FlagEmbedding","type":"model","url":"http://www.bge-model.com/","page_url":"https://unfragile.ai/flagopen--flagembedding","categories":["rag-knowledge"],"tags":["embeddings","information-retrieval","llm","retrieval-augmented-generation","sentence-embeddings","text-semantic-similarity"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-flagopen--flagembedding__cap_0","uri":"capability://memory.knowledge.dense.vector.embedding.generation.with.multi.lingual.support","name":"dense vector embedding generation with multi-lingual support","description":"Converts text input into fixed-dimensional dense vector representations using transformer-based encoder architectures (BGE v1/v1.5 models). Supports 100+ languages through unified embedding space training, enabling semantic similarity comparison across multilingual corpora. Implements contrastive learning with in-batch negatives and hard negative mining to optimize embedding quality for retrieval tasks.","intents":["I need to convert documents and queries into vectors for semantic search","I want to build a multilingual RAG system that handles 50+ languages uniformly","I need embeddings optimized for retrieval rather than general-purpose representation"],"best_for":["Teams building production RAG systems with multilingual content","Developers optimizing vector databases for semantic search","Organizations migrating from sparse retrieval to dense vector search"],"limitations":["BGE v1/v1.5 models have fixed context windows (typically 512 tokens), limiting long-document embedding","Dense embeddings alone cannot capture exact keyword matches — requires hybrid search for keyword-dependent queries","Multilingual embeddings show performance variance across language pairs; some low-resource languages have degraded quality"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.4+","Hugging Face Transformers library","GPU recommended for batch inference (CPU inference ~10x slower)"],"input_types":["plain text strings","document passages (up to 512 tokens)","query strings"],"output_types":["dense float vectors (768 or 1024 dimensions depending on model size)","numpy arrays or PyTorch tensors"],"categories":["memory-knowledge","embeddings"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_1","uri":"capability://memory.knowledge.multi.vector.hybrid.embedding.with.sparse.and.dense.components","name":"multi-vector hybrid embedding with sparse and dense components","description":"BGE-M3 model generates three simultaneous embedding types per input: dense vectors (1024-dim), sparse vectors (lexical matching via learned vocabulary), and multi-vector representations (up to 8192 token context). Enables hybrid retrieval combining dense semantic search with sparse exact-match capabilities in a single forward pass, eliminating need for separate BM25 indexing.","intents":["I need both semantic and keyword-based retrieval in one unified index","I want to handle long documents (8K tokens) without chunking","I need to reduce latency by avoiding separate sparse and dense retrieval pipelines"],"best_for":["Teams building hybrid search systems requiring both semantic and lexical matching","Applications with long-form documents (research papers, legal contracts, technical documentation)","Systems where latency is critical and separate sparse/dense passes are unacceptable"],"limitations":["Sparse vector generation requires learned vocabulary that may not generalize to out-of-domain terms","8192-token context window still requires chunking for documents exceeding this length","Multi-vector output increases storage overhead by 3-4x compared to dense-only embeddings","Sparse component performance degrades on non-English languages despite multilingual training"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.4+","GPU with 8GB+ VRAM for inference (16GB recommended for batch processing)","Vector database supporting sparse vector indexing (e.g., Elasticsearch, Milvus with sparse plugin)"],"input_types":["text passages up to 8192 tokens","multilingual text (100+ languages)"],"output_types":["dense vectors (1024 dimensions)","sparse vectors (variable-length, learned vocabulary indices)","multi-vector representations (concatenated dense + sparse)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_10","uri":"capability://data.processing.analysis.comprehensive.evaluation.framework.with.beir.benchmarking","name":"comprehensive evaluation framework with beir benchmarking","description":"Built-in evaluation system supporting BEIR (Benchmark for Information Retrieval) benchmark suite with 18 diverse retrieval tasks. Implements standard IR metrics (NDCG@10, MRR@10, MAP, Recall@k) and provides evaluation runners that handle data loading, retrieval execution, and metric computation. Enables reproducible model comparison and performance tracking across standard benchmarks.","intents":["I need to benchmark my embeddings against standard retrieval tasks","I want to compare model performance using standard IR metrics","I need reproducible evaluation on diverse retrieval domains"],"best_for":["Researchers evaluating embedding model performance","Teams comparing model variants before production deployment","Organizations tracking model performance over time"],"limitations":["BEIR benchmarks may not reflect domain-specific retrieval characteristics; high BEIR scores don't guarantee production performance","Evaluation on full BEIR suite is computationally expensive (hours to days depending on model size)","Metrics like NDCG@10 may not align with application-specific ranking requirements","Requires downloading BEIR datasets (10GB+); offline evaluation requires pre-cached data"],"requires":["Python 3.8+","PyTorch 1.9+","BEIR dataset (auto-downloaded or pre-cached)","GPU recommended for efficient evaluation","Sufficient disk space for dataset caching (10GB+)"],"input_types":["model instance (embedder or reranker)","BEIR dataset specification","evaluation configuration (metrics, batch size)"],"output_types":["evaluation metrics (NDCG, MRR, MAP, Recall)","per-dataset performance breakdown","evaluation reports (JSON, CSV)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_11","uri":"capability://automation.workflow.batch.inference.with.dynamic.batching.and.gpu.optimization","name":"batch inference with dynamic batching and gpu optimization","description":"Inference system supporting efficient batch processing of queries and documents with dynamic batching to maximize GPU utilization. Implements automatic batch size tuning, mixed-precision inference (FP16), and gradient checkpointing to reduce memory footprint. Supports both synchronous batch inference and asynchronous processing for high-throughput scenarios.","intents":["I need to process large document collections efficiently","I want to maximize GPU utilization for batch embedding generation","I need to reduce inference latency for high-throughput systems"],"best_for":["Batch processing scenarios (indexing document collections)","High-throughput systems processing thousands of queries","Resource-constrained deployments requiring efficient GPU usage"],"limitations":["Dynamic batching adds complexity; requires careful tuning for optimal performance","Mixed-precision inference (FP16) may introduce numerical instability for some downstream tasks","Batch size tuning is hardware-dependent; optimal batch sizes vary across GPU models","Asynchronous processing adds latency variability; unsuitable for latency-sensitive applications"],"requires":["Python 3.8+","PyTorch 1.9+ with CUDA support","GPU with 4GB+ VRAM (8GB+ recommended for large batches)","NVIDIA CUDA toolkit 11.0+ for mixed-precision support"],"input_types":["list of text strings","batch size specification","precision setting (FP32, FP16, INT8)"],"output_types":["batch embeddings (numpy arrays or PyTorch tensors)","performance metrics (throughput, latency)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_12","uri":"capability://memory.knowledge.multi.modal.and.cross.lingual.retrieval.with.unified.embeddings","name":"multi-modal and cross-lingual retrieval with unified embeddings","description":"BGE-M3 and multilingual models enable cross-lingual retrieval by mapping queries and documents from different languages into unified embedding space. Supports retrieval across language boundaries without translation, enabling multilingual RAG systems. Implements language-agnostic dense and sparse representations learned through contrastive objectives on multilingual corpora.","intents":["I need to build a retrieval system supporting 50+ languages","I want to retrieve documents in different languages using queries in any language","I need unified embeddings for multilingual content without translation"],"best_for":["Global applications serving multilingual user bases","Organizations with multilingual document collections","Systems requiring cross-lingual information retrieval"],"limitations":["Cross-lingual retrieval quality varies significantly across language pairs; some pairs show 10-20% performance degradation","Low-resource languages have degraded embedding quality due to limited training data","Unified embedding space requires trade-offs; monolingual models often outperform multilingual variants on single-language tasks","Language detection errors can degrade retrieval quality; requires robust language identification"],"requires":["Python 3.8+","PyTorch 1.9+","Multilingual model (BGE-M3 or language-specific variants)","GPU recommended for efficient inference"],"input_types":["text in any of 100+ supported languages","multilingual document collections"],"output_types":["language-agnostic embeddings","cross-lingual similarity scores"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_2","uri":"capability://memory.knowledge.in.context.learning.for.dynamic.embedding.adaptation","name":"in-context learning for dynamic embedding adaptation","description":"BGE-ICL model enables embedding generation that adapts to task-specific contexts through in-context learning, allowing the embedding space to shift based on provided examples without fine-tuning. Implements prompt-based adaptation where query and document embeddings are influenced by demonstration examples, enabling zero-shot task transfer for domain-specific retrieval.","intents":["I need to adapt embeddings to new domains without retraining models","I want embeddings that understand task-specific relevance from examples","I need to handle domain shift in retrieval without fine-tuning"],"best_for":["Teams with limited labeled data for domain-specific fine-tuning","Applications requiring rapid adaptation to new retrieval tasks","Few-shot learning scenarios where examples define relevance criteria"],"limitations":["In-context learning adds computational overhead (~20-30% slower than standard embeddings) due to example processing","Quality depends heavily on example selection; poor examples degrade performance","Limited to relatively small example sets (typically 1-5 examples) before context window exhaustion","Requires careful prompt engineering to achieve consistent results across different tasks"],"requires":["Python 3.8+","PyTorch 1.9+","GPU recommended (CPU inference impractical for batch processing)","Structured example data with query-document pairs demonstrating task relevance"],"input_types":["query text with optional demonstration examples","document text with optional demonstration examples","example pairs showing task-specific relevance"],"output_types":["context-adapted dense vectors (768 dimensions)","relevance scores influenced by provided examples"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_3","uri":"capability://search.retrieval.cross.encoder.reranking.with.document.query.pair.scoring","name":"cross-encoder reranking with document-query pair scoring","description":"Base reranker models (BGE-reranker-large, BGE-reranker-base) implement cross-encoder architecture that scores document-query pairs directly by processing both inputs jointly through a transformer, producing relevance scores. Unlike embedding-based retrieval, rerankers see full context of both query and document, enabling more accurate ranking but at higher computational cost. Typically applied as second-stage ranker after initial retrieval.","intents":["I need to re-rank initial retrieval results with higher accuracy","I want to improve precision of top-k results without reindexing","I need to score document-query relevance directly rather than through embedding similarity"],"best_for":["Production RAG systems where ranking accuracy is critical","Two-stage retrieval pipelines (dense retrieval + reranking)","Applications with moderate query volume where reranking latency is acceptable"],"limitations":["Reranking is computationally expensive (~100-500ms per query depending on candidate set size), unsuitable for real-time single-query scenarios","Cannot scale to rerank entire corpus; must be applied to pre-filtered candidate sets (typically top-100 from dense retrieval)","Requires processing each document-query pair separately; no batch efficiency gains from processing multiple queries together","Fixed context window (typically 512 tokens) limits ability to rerank long documents"],"requires":["Python 3.8+","PyTorch 1.9+","GPU with 4GB+ VRAM (8GB recommended for batch reranking)","Pre-computed candidate set from initial retrieval stage"],"input_types":["query text string","document text string (up to 512 tokens)","document-query pairs as tuples"],"output_types":["relevance scores (0-1 range)","ranked lists of documents sorted by relevance score"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_4","uri":"capability://search.retrieval.llm.based.reranking.with.generative.scoring","name":"llm-based reranking with generative scoring","description":"BGE-reranker-v2-gemma and similar LLM rerankers use decoder-only language models to generate relevance scores or explanations for document-query pairs. Instead of classification-based scoring, these models generate tokens representing relevance (e.g., 'Yes', 'No', or numeric scores), leveraging LLM reasoning capabilities for more nuanced ranking decisions. Enables interpretable reranking with optional explanation generation.","intents":["I need reranking with explainability — why is this document relevant?","I want to leverage LLM reasoning for complex relevance judgments","I need to handle domain-specific relevance criteria that require semantic reasoning"],"best_for":["Applications requiring explainable ranking decisions","Domain-specific retrieval where relevance requires reasoning (legal, medical, scientific)","Systems where ranking quality justifies higher computational cost"],"limitations":["LLM reranking is 2-5x slower than cross-encoder reranking due to token generation overhead","Requires careful prompt engineering to ensure consistent score generation","Token generation introduces non-determinism; same query-document pair may produce slightly different scores","Explanation generation increases latency further; typically disabled in production for speed"],"requires":["Python 3.8+","PyTorch 1.9+","GPU with 8GB+ VRAM (16GB recommended)","Structured prompts defining relevance criteria and score format"],"input_types":["query text with optional context","document text with optional metadata","relevance criteria as prompt instructions"],"output_types":["generated relevance tokens ('Yes'/'No' or numeric scores)","optional explanation text","confidence scores derived from token probabilities"],"categories":["search-retrieval","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_5","uri":"capability://search.retrieval.specialized.reranker.variants.for.latency.accuracy.trade.offs","name":"specialized reranker variants for latency-accuracy trade-offs","description":"FlagEmbedding provides layerwise and lightweight reranker variants optimizing for different deployment constraints. Layerwise rerankers use intermediate layer outputs for faster scoring with minimal accuracy loss. Lightweight variants use smaller model architectures (MiniCPM-based) reducing memory footprint and inference latency while maintaining reasonable ranking quality. Enables deployment on resource-constrained environments.","intents":["I need reranking on edge devices or CPU-only environments","I want to reduce reranking latency for high-throughput systems","I need to minimize model size while maintaining ranking quality"],"best_for":["Edge deployment scenarios with limited compute","High-throughput systems where reranking latency is bottleneck","Mobile or embedded applications requiring on-device ranking","Cost-sensitive deployments where GPU resources are limited"],"limitations":["Layerwise rerankers sacrifice 2-5% ranking accuracy compared to full-model reranking","Lightweight variants (MiniCPM-based) show 5-10% accuracy degradation on complex relevance judgments","Smaller models have reduced context understanding; perform poorly on nuanced relevance criteria","Latency improvements (30-50% faster) may not justify accuracy loss in high-precision applications"],"requires":["Python 3.8+","PyTorch 1.9+ or ONNX Runtime for optimized inference","2GB+ VRAM for lightweight variants (CPU inference possible but slow)","Quantization support (INT8) for further latency reduction"],"input_types":["query text","document text (up to 512 tokens)","document-query pairs"],"output_types":["relevance scores (0-1 range)","ranked document lists"],"categories":["search-retrieval","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_6","uri":"capability://data.processing.analysis.fine.tuning.framework.for.domain.specific.embeddings","name":"fine-tuning framework for domain-specific embeddings","description":"FlagEmbedding provides end-to-end fine-tuning infrastructure for both embedder and reranker models on custom datasets. Implements contrastive learning objectives for embedders (in-batch negatives, hard negative mining) and ranking losses for rerankers (pairwise ranking, listwise losses). Includes data preparation utilities, training loops with distributed support, and evaluation metrics to measure fine-tuning effectiveness.","intents":["I need to adapt embeddings to my domain-specific corpus","I want to improve reranking performance on my retrieval task","I need to fine-tune models on proprietary data without cloud dependencies"],"best_for":["Teams with domain-specific retrieval tasks and labeled training data","Organizations requiring on-premises model training for data privacy","Applications where pre-trained models underperform on specialized vocabularies"],"limitations":["Requires substantial labeled training data (typically 10K+ query-document pairs) for meaningful improvements","Fine-tuning adds significant development overhead; requires expertise in training loops, hyperparameter tuning, and evaluation","Distributed training setup (multi-GPU) requires additional infrastructure and configuration","Fine-tuned models may overfit to training domain; generalization to new domains often degrades"],"requires":["Python 3.8+","PyTorch 1.9+","GPU with 8GB+ VRAM (16GB+ for distributed training)","Labeled training data in format: (query, positive_document, [negative_documents])","Hugging Face Transformers and Datasets libraries"],"input_types":["training triplets (query, positive, negative)","training pairs (query, document, relevance_label)","raw text corpora for hard negative mining"],"output_types":["fine-tuned model weights (PyTorch checkpoint)","training metrics (loss curves, evaluation scores)","evaluation results on validation set"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_7","uri":"capability://data.processing.analysis.hard.negative.mining.for.training.data.augmentation","name":"hard negative mining for training data augmentation","description":"Utility module that identifies hard negatives (documents that are semantically similar to query but not relevant) from unlabeled corpora using initial embeddings. Augments training datasets by replacing random negatives with hard negatives, improving model robustness to false positives. Implements efficient batch processing to mine negatives from large corpora without exhaustive comparison.","intents":["I need to improve training data quality by finding challenging negatives","I want to reduce false positive rates in my retrieval system","I need to augment limited labeled data with automatically mined hard negatives"],"best_for":["Teams fine-tuning models with limited labeled data","Applications where false positive reduction is critical","Systems where initial embeddings are available but training data is sparse"],"limitations":["Hard negative mining requires initial embeddings; quality depends on pre-trained model quality","Mining process is computationally expensive; requires indexing large corpora and similarity search","Mined negatives may introduce label noise if initial embeddings are poor","Requires careful threshold tuning to balance difficulty and label correctness"],"requires":["Python 3.8+","Initial embeddings from pre-trained model","Vector similarity search library (Faiss, Milvus, or similar)","Unlabeled document corpus for mining"],"input_types":["query embeddings","document embeddings","document corpus","existing training triplets"],"output_types":["augmented training triplets with hard negatives","hard negative statistics (difficulty scores)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_8","uri":"capability://data.processing.analysis.knowledge.distillation.for.model.compression","name":"knowledge distillation for model compression","description":"Framework for distilling large embedding and reranker models into smaller student models, preserving performance while reducing inference latency and memory footprint. Uses teacher-student training where student model learns to match teacher embeddings or scores through KL divergence or MSE losses. Enables deployment of high-quality models on resource-constrained devices.","intents":["I need to deploy embeddings on mobile or edge devices","I want to reduce inference latency without significant accuracy loss","I need smaller models for cost-effective deployment at scale"],"best_for":["Mobile and edge deployment scenarios","High-throughput systems where latency is critical","Cost-sensitive deployments requiring model compression"],"limitations":["Knowledge distillation typically results in 2-5% accuracy loss compared to teacher models","Requires training infrastructure and computational resources for distillation process","Student model architecture must be carefully selected; too small models cannot capture teacher knowledge","Distillation effectiveness depends on teacher model quality; poor teachers produce poor students"],"requires":["Python 3.8+","PyTorch 1.9+","Pre-trained teacher model","GPU with 8GB+ VRAM for distillation training","Training data or unlabeled corpus for distillation"],"input_types":["teacher model weights","student model architecture specification","training corpus (queries and documents)"],"output_types":["compressed student model weights","distillation metrics (KL divergence, accuracy preservation)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-flagopen--flagembedding__cap_9","uri":"capability://tool.use.integration.unified.model.loading.with.automatic.architecture.detection","name":"unified model loading with automatic architecture detection","description":"Auto model loading system that automatically detects model type (embedder vs reranker, encoder-only vs decoder-only, base vs specialized) and instantiates appropriate inference class. Abstracts away architecture-specific implementation details, providing unified interface for loading any BGE model variant. Supports loading from Hugging Face Hub or local paths with automatic configuration parsing.","intents":["I want to load any BGE model without knowing its architecture","I need a unified interface for embedders and rerankers","I want to switch between model variants without code changes"],"best_for":["Developers building flexible RAG systems supporting multiple model variants","Teams experimenting with different model sizes and architectures","Applications requiring easy model swapping for A/B testing"],"limitations":["Auto-detection relies on model naming conventions and config files; custom models may not be detected correctly","Abstraction hides architecture-specific optimizations; advanced users may need direct class instantiation","Loading from Hugging Face Hub requires internet connectivity; offline loading requires pre-downloaded models"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.4+","Hugging Face Transformers library","Internet connectivity for Hub downloads (optional if models pre-cached)"],"input_types":["model identifier string (e.g., 'BAAI/bge-large-en-v1.5')","local model path","model configuration dictionary"],"output_types":["instantiated embedder or reranker object","model metadata (architecture, dimensions, language support)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":37,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.4+","Hugging Face Transformers library","GPU recommended for batch inference (CPU inference ~10x slower)","GPU with 8GB+ VRAM for inference (16GB recommended for batch processing)","Vector database supporting sparse vector indexing (e.g., Elasticsearch, Milvus with sparse plugin)","PyTorch 1.9+","BEIR dataset (auto-downloaded or pre-cached)","GPU recommended for efficient evaluation","Sufficient disk space for dataset caching (10GB+)"],"failure_modes":["BGE v1/v1.5 models have fixed context windows (typically 512 tokens), limiting long-document embedding","Dense embeddings alone cannot capture exact keyword matches — requires hybrid search for keyword-dependent queries","Multilingual embeddings show performance variance across language pairs; some low-resource languages have degraded quality","Sparse vector generation requires learned vocabulary that may not generalize to out-of-domain terms","8192-token context window still requires chunking for documents exceeding this length","Multi-vector output increases storage overhead by 3-4x compared to dense-only embeddings","Sparse component performance degrades on non-English languages despite multilingual training","BEIR benchmarks may not reflect domain-specific retrieval characteristics; high BEIR scores don't guarantee production performance","Evaluation on full BEIR suite is computationally expensive (hours to days depending on model size)","Metrics like NDCG@10 may not align with application-specific ranking requirements","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.35642512285716543,"quality":0.35,"ecosystem":0.5800000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.35,"quality":0.2,"ecosystem":0.1,"match_graph":0.3,"freshness":0.05}},"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-05-03T13:58:29.527Z","last_commit":"2026-04-22T16:00:42Z"},"community":{"stars":11641,"forks":870,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=flagopen--flagembedding","compare_url":"https://unfragile.ai/compare?artifact=flagopen--flagembedding"}},"signature":"k9fDidgx+qC8A+vYuuvHizEAyt+fxme5coC5GbdrPHpUk3oKTuUKcrZOMjO7kVFNwGBP5O0WXJqySoYwprQICQ==","signedAt":"2026-06-21T15:26:21.407Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/flagopen--flagembedding","artifact":"https://unfragile.ai/flagopen--flagembedding","verify":"https://unfragile.ai/api/v1/verify?slug=flagopen--flagembedding","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"}}