{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-1panel-dev--maxkb","slug":"1panel-dev--maxkb","name":"MaxKB","type":"platform","url":"https://maxkb.cn","page_url":"https://unfragile.ai/1panel-dev--maxkb","categories":["ai-agents"],"tags":["agent","agentic-ai","chatbot","deepseek-r1","knowledgebase","langchain","llama3","llm","maxkb","mcp-server","ollama","pgvector","qwen3","rag"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-1panel-dev--maxkb__cap_0","uri":"capability://memory.knowledge.rag.powered.multi.document.knowledge.base.indexing.with.vector.embeddings","name":"rag-powered multi-document knowledge base indexing with vector embeddings","description":"MaxKB implements a document ingestion pipeline that parses uploaded files (PDF, Word, Markdown, etc.), chunks content into paragraphs, generates vector embeddings using PGVector-backed PostgreSQL, and indexes them for semantic retrieval. The system uses Celery for asynchronous batch embedding tasks, enabling non-blocking document processing at scale. Paragraph-level granularity allows fine-grained retrieval and citation tracking.","intents":["I need to upload enterprise documents and make them searchable by semantic meaning, not just keywords","I want to build a knowledge base that scales to thousands of documents without blocking the UI","I need to track which document paragraphs were used to answer a user query for compliance and citation"],"best_for":["enterprises building internal knowledge bases (HR policies, product docs, legal contracts)","teams needing audit trails showing which source documents powered each response","organizations with document-heavy workflows (consulting, legal, healthcare)"],"limitations":["Paragraph chunking is fixed-size; no dynamic sliding window or semantic boundary detection","Embedding generation is synchronous per document batch; very large files (>100MB) may timeout","No built-in deduplication across documents; duplicate content creates redundant embeddings","Vector search relies on PGVector; no support for specialized vector DBs (Pinecone, Weaviate) without custom integration"],"requires":["PostgreSQL 12+ with pgvector extension installed","Python 3.9+","Celery worker process running for async embedding tasks","Embedding model (local or API-based, e.g., OpenAI, Ollama)"],"input_types":["PDF files","Word documents (.docx)","Markdown files","Plain text","Web URLs (via crawler integration)"],"output_types":["Indexed vector embeddings in PGVector","Paragraph metadata (source, page number, chunk index)","Batch processing status and error logs"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_1","uri":"capability://text.generation.language.multi.provider.llm.abstraction.with.streaming.chat.responses","name":"multi-provider llm abstraction with streaming chat responses","description":"MaxKB abstracts multiple LLM providers (OpenAI, Anthropic, Ollama, DeepSeek, Qwen, Llama3) through a unified interface that handles provider-specific API contracts, token counting, and streaming response aggregation. The chat system implements server-sent events (SSE) for real-time token streaming to clients, with built-in fallback handling if a provider fails. Model configuration is stored per-workspace, enabling multi-tenant model isolation.","intents":["I want to switch between different LLM providers (OpenAI to local Ollama) without rewriting chat logic","I need real-time streaming responses to users without waiting for full LLM completion","I want to use the cheapest available model for a task while maintaining the same chat interface"],"best_for":["teams building multi-tenant SaaS platforms with per-customer model selection","enterprises with on-premise LLM requirements (Ollama, local Llama3) and cloud fallbacks","cost-conscious builders wanting to swap providers based on pricing or latency"],"limitations":["Streaming aggregation adds ~50-100ms latency per token due to SSE overhead","No built-in token counting for non-OpenAI models; estimates may be inaccurate for cost tracking","Provider-specific features (vision, function calling) require custom adapter code per provider","Fallback logic is sequential; no parallel provider querying for redundancy"],"requires":["API keys for at least one LLM provider (OpenAI, Anthropic, etc.)","Python 3.9+","Django application running with WebSocket/SSE support","Model configuration stored in workspace settings"],"input_types":["Chat messages (text)","System prompts","Model parameters (temperature, max_tokens, top_p)","Provider credentials (API keys)"],"output_types":["Streamed text tokens (via SSE)","Complete chat messages","Token usage metadata (input/output counts)","Provider response metadata (model name, finish reason)"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_10","uri":"capability://data.processing.analysis.batch.document.processing.and.embedding.status.tracking","name":"batch document processing and embedding status tracking","description":"MaxKB implements a batch processing system for document embedding using Celery task queues. When documents are uploaded to a knowledge base, embedding tasks are queued asynchronously. The system tracks the status of each batch (pending, processing, completed, failed) and provides progress updates via WebSocket or polling. Failed embeddings can be retried with exponential backoff. Batch operations are idempotent; re-processing the same document doesn't create duplicates.","intents":["I want to upload 1000 documents and see real-time progress without blocking the UI","I need to retry failed embeddings automatically without manual intervention","I want to track which documents have been successfully indexed and which failed"],"best_for":["enterprises with large document migrations (>10k documents)","teams needing reliable batch processing with failure recovery","platforms where document indexing happens in the background"],"limitations":["Batch processing latency depends on Celery worker availability; slow workers delay embedding completion","No built-in deduplication; uploading the same document twice creates duplicate embeddings","Progress tracking is eventual-consistent; UI may show stale status briefly","Retry logic is exponential backoff; no intelligent retry strategies based on failure type","No built-in cost tracking; embedding large batches may incur unexpected API charges"],"requires":["Celery worker process running","Redis or RabbitMQ for task queue","Python 3.9+","Embedding model (local or API-based)"],"input_types":["Document batch (list of files)","Batch metadata (knowledge base ID, tags)","Retry configuration (max retries, backoff strategy)"],"output_types":["Batch status (pending, processing, completed, failed)","Progress percentage","Per-document status (success, error message)","Batch completion timestamp"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_11","uri":"capability://tool.use.integration.model.provider.configuration.and.credential.management","name":"model provider configuration and credential management","description":"MaxKB provides a centralized model management interface where users configure LLM providers (OpenAI, Anthropic, Ollama, DeepSeek, Qwen, Llama3) with API keys and model parameters. Credentials are encrypted at rest and never logged. The system validates provider connectivity on configuration and provides fallback options if a provider fails. Model configurations are workspace-scoped, enabling different teams to use different providers.","intents":["I want to configure multiple LLM providers and switch between them based on cost or availability","I need to securely store API keys without exposing them in logs or configuration files","I want to validate that my LLM provider is working before deploying an application"],"best_for":["multi-tenant platforms where each customer uses their own API keys","enterprises with strict credential management policies","teams evaluating multiple LLM providers"],"limitations":["Credential encryption is at-rest only; credentials in memory are not encrypted","No built-in credential rotation; API key updates require manual intervention","Provider validation is one-time; no continuous health checks","No cost tracking per provider; billing must be tracked externally","Fallback logic is manual; no automatic provider selection based on latency or cost"],"requires":["API keys for LLM providers","Python 3.9+","Encryption key for credential storage (Django SECRET_KEY)","PostgreSQL for credential storage"],"input_types":["Provider type (OpenAI, Anthropic, Ollama, etc.)","API key or credentials","Model name","Custom parameters (temperature, max_tokens, etc.)"],"output_types":["Provider configuration (encrypted)","Validation status (success/failure)","Available models for the provider","Provider metadata (rate limits, supported features)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_2","uri":"capability://planning.reasoning.node.based.workflow.orchestration.engine.with.conditional.branching","name":"node-based workflow orchestration engine with conditional branching","description":"MaxKB provides a visual workflow designer where users compose multi-step AI tasks using nodes (LLM, tool execution, conditional logic, data transformation). The workflow execution engine interprets the node graph, manages state between steps, handles branching based on conditions, and supports error recovery. Workflows can chain LLM calls with tool execution, knowledge base retrieval, and custom code execution in a DAG-like structure.","intents":["I need to build a multi-step agent that decides whether to search the knowledge base or call an API based on the user query","I want to create a workflow that loops through a list of items, processing each with an LLM, without writing code","I need to handle errors gracefully (e.g., if an API call fails, try a fallback tool)"],"best_for":["non-technical business users building complex agent logic without coding","teams automating multi-step customer support workflows (classify → search KB → escalate)","enterprises needing audit trails of workflow execution for compliance"],"limitations":["No built-in loop constructs; iteration requires manual node duplication or custom code nodes","Conditional branching is limited to simple boolean logic; complex decision trees require multiple nodes","Workflow state is not persisted between sessions; long-running workflows cannot be paused/resumed","Debugging is limited to execution logs; no step-by-step breakpoint inspection"],"requires":["Django application with workflow engine service running","At least one LLM provider configured","Python 3.9+","PostgreSQL for workflow definition and execution history storage"],"input_types":["Workflow node definitions (JSON graph structure)","User input (text, files)","Tool/API responses","Knowledge base query results"],"output_types":["Workflow execution result (final output)","Execution trace (node-by-node logs)","Intermediate step outputs","Error messages and recovery actions"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_3","uri":"capability://tool.use.integration.sandboxed.custom.tool.code.execution.with.system.call.interception","name":"sandboxed custom tool code execution with system call interception","description":"MaxKB allows users to define custom tools by uploading Python code that runs in an isolated sandbox environment. The sandbox uses a C library (sandbox.so) to intercept system calls, preventing malicious code from accessing the filesystem, network, or process management. Tool execution is async and integrated into workflows, allowing LLMs to call custom logic (e.g., database queries, API transformations) safely.","intents":["I want to let users define custom tools (e.g., database queries) without risking the security of the platform","I need to execute untrusted Python code from workflows without allowing it to access sensitive files or networks","I want to integrate proprietary business logic (custom calculations, data transformations) into agent workflows"],"best_for":["multi-tenant SaaS platforms where customers upload custom tool code","enterprises with strict security requirements (financial services, healthcare)","teams building extensible agent platforms where plugins are user-provided"],"limitations":["Sandbox overhead adds ~200-500ms per tool execution due to system call interception","No network access from sandboxed code; external APIs must be called via pre-defined tool wrappers","Limited to Python; no support for other languages (Go, Rust, Node.js)","Sandbox is process-level; no isolation between concurrent tool executions on the same worker","Debugging sandboxed code is difficult; error messages may not include full stack traces"],"requires":["Linux OS (sandbox.so is Linux-specific; Windows/macOS not supported)","Python 3.9+","C compiler to build sandbox.so from source","Celery worker process with sandbox library loaded"],"input_types":["Python source code (uploaded as file or pasted)","Tool input parameters (JSON)","Execution context (workflow state, user data)"],"output_types":["Tool execution result (JSON)","Execution logs and errors","Performance metrics (execution time, memory used)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_4","uri":"capability://safety.moderation.multi.tenant.workspace.isolation.with.role.based.access.control","name":"multi-tenant workspace isolation with role-based access control","description":"MaxKB implements workspace-level multi-tenancy where each workspace has isolated data (knowledge bases, applications, workflows, models). Access control is enforced through role-based permissions (admin, editor, viewer) with granular resource-level checks. User authentication supports LDAP, OAuth2, and local credentials. Workspace membership and permissions are stored in PostgreSQL with audit logging of all permission changes.","intents":["I need to build a SaaS platform where each customer has their own isolated knowledge base and workflows","I want to grant different team members different permissions (some can edit workflows, others can only view results)","I need an audit trail showing who accessed or modified what data for compliance"],"best_for":["SaaS platforms serving multiple organizations with data isolation requirements","enterprises with strict access control policies (finance, healthcare, government)","teams needing fine-grained permission management across large user bases"],"limitations":["Workspace isolation is logical (database-level), not physical; a database breach exposes all workspaces","Permission checks are enforced at the API layer; no row-level security in the database","LDAP/OAuth2 integration requires manual configuration per deployment","No built-in support for cross-workspace data sharing or federation","Audit logs are append-only; no built-in retention policies or archival"],"requires":["PostgreSQL 12+ with proper user isolation configured","Django authentication backend (LDAP, OAuth2, or local)","Python 3.9+","Redis for session management (optional but recommended)"],"input_types":["User credentials (username/password, LDAP, OAuth2 tokens)","Workspace membership requests","Permission assignments (role + resource)"],"output_types":["Authentication tokens (JWT or session cookies)","Workspace list (filtered by user permissions)","Audit log entries (user, action, resource, timestamp)"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_5","uri":"capability://search.retrieval.semantic.search.across.knowledge.base.with.hybrid.retrieval","name":"semantic search across knowledge base with hybrid retrieval","description":"MaxKB implements vector-based semantic search using PGVector embeddings combined with optional keyword/BM25 matching for hybrid retrieval. When a user query arrives, it's embedded and compared against indexed paragraphs using cosine similarity. Results are ranked by relevance score and returned with source document metadata. The system supports filtering by document, knowledge base, or custom metadata tags.","intents":["I want to find relevant documents based on meaning, not just keyword matching (e.g., 'how do I reset my password' should match 'password reset procedure')","I need to search across thousands of documents and get the top-5 most relevant results in <500ms","I want to filter search results by document type or date range while maintaining semantic relevance"],"best_for":["customer support teams building AI-powered help desks","enterprises with large document repositories (>10k documents)","teams needing fast semantic search without external vector DB costs"],"limitations":["Search latency increases with knowledge base size; >100k paragraphs may exceed 1s response time","Embedding quality depends on the embedding model; domain-specific embeddings require fine-tuning","No built-in relevance feedback loop; ranking cannot be improved based on user clicks","Hybrid retrieval (semantic + keyword) requires manual weight tuning; no automatic optimization","Search results are limited to indexed paragraphs; real-time data or external sources cannot be searched"],"requires":["PostgreSQL 12+ with pgvector extension","Embedding model (local or API-based)","Python 3.9+","Knowledge base with indexed documents"],"input_types":["User query (text)","Filter criteria (document ID, tags, date range)","Search parameters (top-k, similarity threshold)"],"output_types":["Ranked list of relevant paragraphs","Similarity scores (0-1)","Source document metadata (title, URL, page number)","Highlighted excerpt from each result"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_6","uri":"capability://memory.knowledge.chat.history.and.session.management.with.multi.platform.support","name":"chat history and session management with multi-platform support","description":"MaxKB maintains persistent chat sessions with full message history, including user inputs, LLM responses, tool calls, and knowledge base citations. Sessions are stored per-application and can be accessed via web UI, mobile app, or API. The system supports session branching (creating alternative conversation paths) and message editing with automatic re-generation of downstream responses. Chat context is managed per-session to avoid token limit overflow.","intents":["I want users to be able to continue conversations across multiple sessions without losing context","I need to show users which documents or tools were used to generate each response","I want to allow users to edit a previous message and see how the conversation would change"],"best_for":["customer support platforms where agents need conversation history","research tools where users explore topics iteratively","enterprise chatbots where audit trails of conversations are required"],"limitations":["Session branching creates exponential storage overhead; deep branching trees may cause performance issues","Message editing requires re-generating all downstream responses; long conversations may timeout","Chat context is truncated when approaching token limits; no intelligent summarization of old messages","Multi-platform sync is eventual-consistent; mobile and web clients may see stale data briefly","No built-in conversation anonymization; sensitive data in chat history requires manual cleanup"],"requires":["PostgreSQL for session and message storage","Python 3.9+","Redis for session caching (optional but recommended)","LLM provider with sufficient context window"],"input_types":["Chat messages (text, files)","Session ID or creation request","Message edit operations","Session branching requests"],"output_types":["Chat history (paginated message list)","Session metadata (created_at, last_updated, message_count)","Message citations (source documents, tool calls)","Session branches (alternative conversation paths)"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_7","uri":"capability://data.processing.analysis.file.upload.and.speech.to.text.transcription.for.chat.input","name":"file upload and speech-to-text transcription for chat input","description":"MaxKB allows users to upload files (images, PDFs, audio) and audio files are automatically transcribed to text using speech-to-text models. Uploaded files are stored in a file service (local filesystem or S3-compatible storage) and can be referenced in chat messages. Images are processed for OCR if needed, and PDFs can be added directly to knowledge bases. File metadata (size, type, upload timestamp) is tracked for audit purposes.","intents":["I want users to upload voice messages and have them automatically converted to text for the AI to process","I need to allow users to share images or documents in chat and have the AI analyze them","I want to ingest PDFs directly into the knowledge base without manual conversion"],"best_for":["mobile-first chat applications where voice input is common","document-heavy workflows (legal, healthcare, consulting)","accessibility-focused platforms supporting multiple input modalities"],"limitations":["Speech-to-text accuracy depends on audio quality and language; accented speech may have high error rates","File uploads are synchronous; large files (>500MB) may timeout or consume excessive memory","OCR is not built-in; image text extraction requires integration with external services (Tesseract, AWS Textract)","File storage is not encrypted by default; sensitive documents require additional security configuration","No built-in virus scanning; uploaded files should be scanned by external antivirus service"],"requires":["Speech-to-text model (local or API-based, e.g., Whisper, Google Cloud Speech)","File storage backend (local filesystem or S3-compatible service)","Python 3.9+","Django file upload handling configured"],"input_types":["Audio files (MP3, WAV, OGG, M4A)","Image files (PNG, JPG, GIF)","PDF documents","Other document types (DOCX, TXT, Markdown)"],"output_types":["Transcribed text (from audio)","File metadata (size, type, upload timestamp)","File URLs (for reference in chat)","OCR text (if image processing enabled)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_8","uri":"capability://tool.use.integration.mcp.model.context.protocol.server.integration.for.tool.discovery.and.execution","name":"mcp (model context protocol) server integration for tool discovery and execution","description":"MaxKB implements the Model Context Protocol (MCP) standard, allowing it to act as an MCP server that exposes tools to LLM clients. Tools are discovered dynamically via MCP, and their schemas are registered with the LLM for function calling. When an LLM decides to call a tool, MaxKB executes it (either as a sandboxed Python function or an external API call) and returns the result to the LLM. This enables seamless tool integration without hardcoding tool definitions.","intents":["I want my LLM to discover and call tools dynamically without me manually defining their schemas","I need to expose MaxKB's tools (knowledge base search, workflow execution) to external LLM clients via MCP","I want to integrate third-party tools (Slack, Jira, Salesforce) into my agent without custom code"],"best_for":["teams building extensible agent platforms with dynamic tool discovery","enterprises integrating MaxKB with external LLM clients (Claude, GPT-4)","organizations standardizing on MCP for tool interoperability"],"limitations":["MCP is a relatively new standard; not all LLM providers support it natively (OpenAI requires custom integration)","Tool schema discovery adds latency (~100-200ms) at the start of each conversation","Error handling in MCP is limited; tool failures may not propagate clearly to the LLM","No built-in rate limiting or quota management for tool calls via MCP","Debugging MCP interactions requires protocol-level logging; standard LLM logs may not show tool details"],"requires":["MCP-compatible LLM client (Claude, or custom client with MCP support)","Python 3.9+","MaxKB server running with MCP endpoint exposed","Tool definitions registered in MaxKB"],"input_types":["Tool schema definitions (JSON)","Tool invocation requests (via MCP protocol)","Tool input parameters"],"output_types":["Tool execution results (JSON)","Tool schema catalog (for discovery)","Execution logs and errors"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-1panel-dev--maxkb__cap_9","uri":"capability://automation.workflow.application.management.with.configurable.chat.pipelines","name":"application management with configurable chat pipelines","description":"MaxKB allows users to create applications (chatbots, agents) with customizable chat pipelines. Each application has a configuration that specifies the LLM model, system prompt, knowledge base to use, tools to enable, and workflow to execute. The chat pipeline orchestrates the flow: user input → knowledge base retrieval → LLM reasoning → tool execution → response generation. Applications can be deployed as web widgets, APIs, or standalone interfaces.","intents":["I want to create multiple chatbots with different personalities and knowledge bases without duplicating code","I need to configure which tools and knowledge bases a specific chatbot can access","I want to deploy the same chatbot logic across web, mobile, and Slack without rebuilding"],"best_for":["teams managing multiple chatbots with different configurations","enterprises deploying the same agent logic across multiple channels","non-technical users creating chatbots without coding"],"limitations":["Pipeline configuration is static; dynamic pipeline changes require application restart","No A/B testing framework; comparing different configurations requires manual setup","Application versioning is not built-in; rolling back to previous configurations requires manual snapshots","Multi-channel deployment (web, Slack, Teams) requires separate connector implementations","No built-in analytics; tracking application usage requires external logging"],"requires":["Python 3.9+","Django application with application management service","At least one LLM provider configured","Knowledge base (optional, depending on use case)"],"input_types":["Application configuration (JSON or form)","System prompt","Model selection","Knowledge base selection","Tool/workflow selection"],"output_types":["Application instance (with unique ID and API endpoint)","Deployment URLs (web widget, API, etc.)","Application settings (for editing)"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":39,"verified":false,"data_access_risk":"high","permissions":["PostgreSQL 12+ with pgvector extension installed","Python 3.9+","Celery worker process running for async embedding tasks","Embedding model (local or API-based, e.g., OpenAI, Ollama)","API keys for at least one LLM provider (OpenAI, Anthropic, etc.)","Django application running with WebSocket/SSE support","Model configuration stored in workspace settings","Celery worker process running","Redis or RabbitMQ for task queue","Embedding model (local or API-based)"],"failure_modes":["Paragraph chunking is fixed-size; no dynamic sliding window or semantic boundary detection","Embedding generation is synchronous per document batch; very large files (>100MB) may timeout","No built-in deduplication across documents; duplicate content creates redundant embeddings","Vector search relies on PGVector; no support for specialized vector DBs (Pinecone, Weaviate) without custom integration","Streaming aggregation adds ~50-100ms latency per token due to SSE overhead","No built-in token counting for non-OpenAI models; estimates may be inaccurate for cost tracking","Provider-specific features (vision, function calling) require custom adapter code per provider","Fallback logic is sequential; no parallel provider querying for redundancy","Batch processing latency depends on Celery worker availability; slow workers delay embedding completion","No built-in deduplication; uploading the same document twice creates duplicate embeddings","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3859009657481883,"quality":0.34,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.25,"ecosystem":0.15,"match_graph":0.25,"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.549Z","last_scraped_at":"2026-05-03T13:56:56.344Z","last_commit":"2026-04-30T06:39:05Z"},"community":{"stars":20871,"forks":2812,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=1panel-dev--maxkb","compare_url":"https://unfragile.ai/compare?artifact=1panel-dev--maxkb"}},"signature":"jkii0XGovs9Q39zR+ma/23SUlYJdpN8EYe1QHSXbw4ZO0A3b6x7VN+nLg3O6hwVctuoZjt4V7VtoggkX/i1cBw==","signedAt":"2026-06-20T00:39:53.531Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/1panel-dev--maxkb","artifact":"https://unfragile.ai/1panel-dev--maxkb","verify":"https://unfragile.ai/api/v1/verify?slug=1panel-dev--maxkb","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"}}