{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge","slug":"the-pocket--pocketflow-tutorial-codebase-knowledge","name":"PocketFlow-Tutorial-Codebase-Knowledge","type":"agent","url":"https://code2tutorial.com/ ","page_url":"https://unfragile.ai/the-pocket--pocketflow-tutorial-codebase-knowledge","categories":["chatbots-assistants"],"tags":["coding","large-language-model","large-language-models","llm","llm-agent","llm-agents","llm-application","llm-apps","llm-framework","llm-frameworks","llms","pocket-flow","pocketflow"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"pending_review","verified":false},"capabilities":[{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_0","uri":"capability://automation.workflow.sequential.codebase.to.tutorial.pipeline.orchestration.via.pocketflow","name":"sequential codebase-to-tutorial pipeline orchestration via pocketflow","description":"Orchestrates a six-node sequential workflow (FetchRepo → IdentifyAbstractions → AnalyzeRelationships → OrderChapters → WriteChapters → CombineTutorial) using PocketFlow's node-chaining pattern with the >> operator. Each node implements a prep-exec-post lifecycle, passing results through a shared dictionary that acts as a central state store. Nodes are executed sequentially with automatic data threading between stages, eliminating manual context passing.","intents":["I want to automate the entire process of converting a GitHub repository into structured tutorial documentation without manual orchestration","I need a framework that chains multiple LLM calls together while maintaining state across pipeline stages","I want to define complex multi-step workflows declaratively without writing boilerplate orchestration code"],"best_for":["Teams building LLM-powered documentation generation systems","Developers creating multi-stage code analysis pipelines","Organizations automating knowledge extraction from codebases"],"limitations":["Sequential execution only — no parallel node processing, limiting throughput for large codebases","Shared dictionary state store has no built-in persistence or recovery — pipeline failure loses intermediate results","No conditional branching or dynamic node selection — all six nodes execute regardless of input characteristics"],"requires":["Python 3.8+","PocketFlow framework installed","LLM API credentials (OpenAI, Anthropic, or local Ollama)","Git CLI for repository cloning"],"input_types":["GitHub repository URL","Local directory path","File inclusion/exclusion patterns (glob syntax)"],"output_types":["Markdown tutorial chapters","Mermaid diagrams","Jekyll-compatible documentation site","JSON metadata (abstractions, relationships, chapter order)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_1","uri":"capability://data.processing.analysis.multi.source.codebase.ingestion.with.pattern.based.filtering","name":"multi-source codebase ingestion with pattern-based filtering","description":"The FetchRepo node ingests code from GitHub repositories or local directories, applying include/exclude glob patterns to filter files before processing. Implements dual crawling strategies: GitHubRepositoryCrawler for remote repos (clones via git CLI) and LocalDirectoryCrawler for local paths (filesystem traversal). Outputs a files dictionary mapping file paths to source code content, with language detection based on file extensions.","intents":["I want to analyze only specific parts of a codebase (e.g., src/ but not tests/ or node_modules/)","I need to fetch and process code from both GitHub and local directories with a unified interface","I want to automatically detect programming language from file extensions for language-specific analysis"],"best_for":["Developers generating tutorials from public GitHub repositories","Teams documenting internal codebases stored locally","Organizations needing flexible source filtering (exclude vendor code, tests, build artifacts)"],"limitations":["GitHub crawling requires public repository access — private repos need authentication token not currently exposed in CLI","Pattern matching uses simple glob syntax — no regex support for complex filtering rules","Language detection relies on file extension only — no content-based language detection for ambiguous files"],"requires":["Git CLI installed and in PATH (for GitHub cloning)","Read permissions on local directories","Python 3.8+"],"input_types":["GitHub HTTPS URL (e.g., https://github.com/user/repo)","Local directory path (absolute or relative)","Glob patterns for inclusion (e.g., src/**/*.py)","Glob patterns for exclusion (e.g., tests/**, node_modules/**)"],"output_types":["Dictionary mapping file paths to source code strings","Project name extracted from repo name or directory","Detected programming language list"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_10","uri":"capability://memory.knowledge.incremental.codebase.analysis.with.file.level.caching","name":"incremental codebase analysis with file-level caching","description":"The pipeline implements caching at two levels: (1) prompt-level caching in call_llm() to avoid regenerating identical LLM responses, and (2) file-level caching in FetchRepo to avoid re-cloning unchanged repositories. Cache keys are derived from repository URL/path and file content hashes. Cached results are stored in a local cache directory (.pocketflow_cache by default) and reused across pipeline runs, enabling fast iteration and cost reduction.","intents":["I want to re-run the pipeline on the same codebase without re-fetching or re-analyzing unchanged files","I need to reduce LLM API costs by caching responses for identical prompts across multiple tutorial generation runs","I want to iterate quickly on tutorial generation without waiting for full re-analysis"],"best_for":["Teams iterating on tutorial generation with cost-sensitive LLM usage","Developers generating tutorials for multiple versions of the same codebase","Organizations running tutorial generation on a schedule with incremental updates"],"limitations":["Cache invalidation is manual — no automatic detection of stale cache entries when code changes","Cache is local filesystem-based — no distributed caching for multi-machine deployments or CI/CD pipelines","Cache key for files is content-hash only — moving or renaming files without content changes creates new cache entries"],"requires":["Write permissions on cache directory (.pocketflow_cache or configured path)","Sufficient disk space for cached files and LLM responses","Python 3.8+"],"input_types":["Repository URL or local path (cache key)","File content (for content-hash caching)"],"output_types":["Cached file contents and LLM responses","Cache metadata (timestamps, hit/miss counts)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_11","uri":"capability://data.processing.analysis.structured.abstraction.and.relationship.extraction.with.json.output","name":"structured abstraction and relationship extraction with json output","description":"The pipeline outputs abstractions and relationships as structured JSON/dict objects, not just markdown text. Each abstraction includes name, description, file location, and type (class, function, module, pattern). Each relationship includes source, target, type (uses, imports, extends, calls), and strength. This structured output enables downstream processing, visualization, and integration with other tools. The JSON format is documented and stable across versions.","intents":["I want to extract structured data about code abstractions and relationships for programmatic processing","I need to integrate tutorial generation with other tools (e.g., architecture visualization, dependency analysis)","I want to build custom visualizations or reports from the extracted abstractions and relationships"],"best_for":["Teams building custom tools on top of PocketFlow's analysis","Organizations integrating tutorial generation with architecture analysis pipelines","Developers creating visualizations or reports from codebase structure"],"limitations":["JSON schema is not formally documented — structure may change between versions without warning","No validation of extracted abstractions — LLM may produce invalid or incomplete JSON","No query language for filtering or transforming structured output — users must parse JSON manually"],"requires":["JSON parsing library (built-in to Python)","Understanding of abstraction and relationship data model"],"input_types":["LLM-generated abstraction and relationship descriptions"],"output_types":["JSON objects with abstraction metadata (name, description, location, type)","JSON objects with relationship metadata (source, target, type, strength)","Structured data suitable for programmatic processing"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_2","uri":"capability://text.generation.language.llm.driven.core.abstraction.identification.from.source.code","name":"llm-driven core abstraction identification from source code","description":"The IdentifyAbstractions node uses an LLM to analyze source code files and extract core abstractions (classes, functions, modules, patterns) that form the conceptual foundation of the codebase. Sends the files dictionary and detected language to the LLM with a prompt engineered to identify pedagogically relevant abstractions. Returns a structured list of abstractions with descriptions, enabling downstream nodes to build relationships and ordering.","intents":["I want to automatically identify the key concepts and abstractions in a codebase without manual code review","I need the LLM to understand language-specific patterns (e.g., Python decorators, JavaScript closures) when extracting abstractions","I want abstractions to be pedagogically ordered, not just syntactically extracted"],"best_for":["Documentation teams generating tutorials from unfamiliar codebases","Open-source maintainers creating contributor onboarding guides","Developers building knowledge bases from legacy code"],"limitations":["LLM accuracy depends on code quality and documentation — poorly documented code produces weak abstractions","Token limits constrain maximum codebase size per call — large repos may require chunking not currently implemented","No validation that identified abstractions are actually used or important — LLM may hallucinate irrelevant concepts"],"requires":["LLM API access (OpenAI, Anthropic, or local Ollama)","API key configured in environment or config file","Source code files from FetchRepo node","Detected programming language"],"input_types":["Dictionary of file paths → source code content","Project name string","Programming language string"],"output_types":["List of abstraction objects with name, description, and file location","Structured JSON or dict format for downstream processing"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_3","uri":"capability://text.generation.language.semantic.relationship.mapping.between.code.abstractions","name":"semantic relationship mapping between code abstractions","description":"The AnalyzeRelationships node uses an LLM to map dependencies and relationships between identified abstractions (e.g., 'ClassA uses ClassB', 'FunctionX calls FunctionY', 'ModuleA imports ModuleB'). Takes abstractions list and source files as input, prompts the LLM to analyze call graphs and dependency patterns, and outputs a relationships graph. This graph is used by downstream nodes to determine pedagogical ordering and chapter structure.","intents":["I want to understand how abstractions depend on each other to order tutorial chapters from foundational to advanced","I need to identify which abstractions are prerequisites for understanding others","I want to visualize the architecture of a codebase as a dependency graph for documentation"],"best_for":["Tutorial authors creating progressive learning paths through complex codebases","Architecture documentation teams mapping system dependencies","Developers onboarding to unfamiliar projects needing dependency context"],"limitations":["LLM relationship inference may miss implicit dependencies (e.g., shared state, event-driven coupling) not visible in direct code references","Circular dependencies are not resolved — the graph may contain cycles that confuse downstream ordering algorithms","No distinction between strong (required) and weak (optional) dependencies — all relationships weighted equally"],"requires":["LLM API access","Abstractions list from IdentifyAbstractions node","Source code files from FetchRepo node","Programming language context"],"input_types":["List of abstraction objects with names and descriptions","Dictionary of file paths → source code content","Programming language string"],"output_types":["Relationship graph (adjacency list or edge list format)","Dependency matrix or structured JSON with source → target relationships","Relationship types (uses, imports, extends, calls, etc.)"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_4","uri":"capability://planning.reasoning.pedagogical.chapter.ordering.via.topological.sort.with.llm.guidance","name":"pedagogical chapter ordering via topological sort with llm guidance","description":"The OrderChapters node uses the relationships graph to determine optimal chapter ordering for the tutorial. Applies topological sorting to the dependency graph to ensure prerequisites are covered before dependent concepts. Uses an LLM to refine the ordering based on pedagogical principles (e.g., 'start with simple examples before complex patterns'). Outputs a chapter_order list that sequences abstractions from foundational to advanced, with grouping suggestions for related concepts.","intents":["I want to automatically determine the best order to teach concepts in a tutorial based on their dependencies","I need to group related abstractions into chapters that flow logically","I want the tutorial to start with simple, foundational concepts and progress to advanced patterns"],"best_for":["Tutorial authors creating learning paths through complex systems","Documentation teams ensuring pedagogical coherence across chapters","Educators designing curriculum from existing codebases"],"limitations":["Topological sort fails on circular dependencies — requires manual intervention to break cycles","LLM refinement is non-deterministic — same input may produce different orderings across runs","No consideration of estimated learning time or difficulty levels — all abstractions treated as equal complexity"],"requires":["LLM API access","Abstractions list from IdentifyAbstractions node","Relationships graph from AnalyzeRelationships node","Programming language context"],"input_types":["List of abstraction objects","Relationship graph (edges between abstractions)","Programming language string"],"output_types":["Ordered list of abstractions (chapter sequence)","Chapter groupings (which abstractions belong in same chapter)","Dependency metadata for each chapter (prerequisites)"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_5","uri":"capability://text.generation.language.batch.llm.based.tutorial.chapter.generation.with.caching","name":"batch llm-based tutorial chapter generation with caching","description":"The WriteChapters BatchNode generates tutorial content for each chapter in the ordered sequence using batch LLM calls. For each abstraction in chapter_order, constructs a detailed prompt including the abstraction description, related code snippets, dependencies, and pedagogical context. Implements caching via call_llm(prompt, use_cache=True) to avoid regenerating identical chapters. Outputs chapters dictionary mapping chapter names to markdown content with code examples, explanations, and learning objectives.","intents":["I want to generate tutorial chapter content automatically for each identified abstraction","I need to include relevant code examples and explanations in each chapter","I want to cache generated chapters to avoid redundant LLM calls and reduce costs"],"best_for":["Documentation teams generating large tutorial suites from multiple codebases","Open-source projects creating contributor onboarding documentation","Organizations building internal knowledge bases with cost-sensitive LLM usage"],"limitations":["Batch processing is sequential — no parallelization across chapters, limiting throughput for large tutorials","Cache key is prompt-based — any prompt variation (e.g., whitespace, parameter order) creates new cache entries, reducing hit rates","Generated content quality depends heavily on prompt engineering — poor prompts produce shallow or inaccurate chapters"],"requires":["LLM API access with sufficient quota for batch calls","Chapter order from OrderChapters node","Abstractions list with descriptions","Source code files for context","Optional: local cache directory for prompt-response pairs"],"input_types":["Ordered list of abstractions to write chapters for","Abstraction descriptions and relationships","Source code snippets for examples","Chapter grouping metadata"],"output_types":["Dictionary mapping chapter names to markdown content","Markdown with embedded code blocks, headers, and learning objectives","Cache entries (prompt → response pairs) for future reuse"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_6","uri":"capability://text.generation.language.multi.format.tutorial.output.generation.markdown.mermaid.jekyll","name":"multi-format tutorial output generation (markdown, mermaid, jekyll)","description":"The CombineTutorial node assembles generated chapters into multiple output formats: Markdown files (one per chapter), Mermaid diagrams (architecture and dependency visualizations), and a Jekyll-compatible documentation site structure. Takes all pipeline outputs (chapters, abstractions, relationships, chapter_order) and generates a complete tutorial package. Outputs to a configurable output_dir with subdirectories for chapters, diagrams, and static site assets. Supports multi-language documentation via language-specific templates.","intents":["I want to generate a complete, ready-to-publish tutorial package from a codebase in one command","I need multiple output formats (Markdown for GitHub, Mermaid diagrams for architecture docs, Jekyll site for hosting)","I want to create a professional documentation site that can be deployed to GitHub Pages or other static hosts"],"best_for":["Open-source projects publishing tutorials to GitHub or documentation sites","Organizations creating internal knowledge bases with Jekyll hosting","Teams needing both source documentation (Markdown) and visual diagrams (Mermaid)"],"limitations":["Jekyll output requires Jekyll installation and Ruby environment for local testing — not portable without additional setup","Mermaid diagram generation is automatic but may produce cluttered visualizations for large dependency graphs","No customization of output templates — generated sites use fixed layout and styling"],"requires":["All outputs from previous pipeline nodes (chapters, abstractions, relationships, chapter_order)","Write permissions on output_dir","Optional: Jekyll installed for local site testing","Optional: Mermaid CLI for diagram rendering to PNG/SVG"],"input_types":["Chapters dictionary (markdown content)","Abstractions list with metadata","Relationships graph","Chapter order and groupings","Output directory path"],"output_types":["Markdown files (one per chapter, in chapters/ subdirectory)","Mermaid diagram files (.mmd format) for architecture visualization","Jekyll site structure (index.md, _config.yml, assets/)","Static HTML (if Jekyll rendering enabled)","Directory structure with metadata files"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_7","uri":"capability://tool.use.integration.multi.provider.llm.abstraction.with.configurable.model.selection","name":"multi-provider llm abstraction with configurable model selection","description":"The call_llm(prompt, use_cache) utility function abstracts LLM provider differences, supporting OpenAI, Anthropic, and local Ollama models. Reads model configuration from environment variables or config file (MODEL_PROVIDER, MODEL_NAME, API_KEY). Routes prompts to the appropriate provider's API with consistent request/response handling. Implements caching via prompt-hash-based key lookup in a local cache store, returning cached responses without API calls for identical prompts.","intents":["I want to switch between LLM providers (OpenAI, Anthropic, Ollama) without changing pipeline code","I need to cache LLM responses to reduce API costs and latency for repeated prompts","I want to use local Ollama models for privacy-sensitive codebases without sending code to cloud APIs"],"best_for":["Teams evaluating different LLM providers for cost/quality tradeoffs","Organizations with privacy requirements needing local model support","Developers iterating on tutorial generation with cost-sensitive API usage"],"limitations":["Cache is local filesystem-based — no distributed caching for multi-machine deployments","Cache key is prompt-hash only — no versioning or invalidation strategy for stale cached responses","Provider-specific features (e.g., vision models, function calling) are not exposed — abstraction hides advanced capabilities"],"requires":["API key for selected provider (OPENAI_API_KEY, ANTHROPIC_API_KEY, or local Ollama running on localhost:11434)","Environment variables or config file with MODEL_PROVIDER and MODEL_NAME","Python 3.8+","requests library for HTTP calls"],"input_types":["Prompt string (any length, but subject to provider token limits)","use_cache boolean flag (default True)"],"output_types":["LLM response string (completion text)","Cache hit/miss metadata (for logging)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_8","uri":"capability://automation.workflow.cli.driven.configuration.and.execution.with.docker.support","name":"cli-driven configuration and execution with docker support","description":"The main.py CLI interface parses command-line arguments for repository URL/local path, output directory, include/exclude patterns, and LLM configuration. Initializes a shared dictionary with all configuration parameters and invokes create_tutorial_flow() to execute the pipeline. Supports Docker containerization via Dockerfile, enabling reproducible execution across environments. Configuration can be provided via CLI flags, environment variables, or config file (config.yaml).","intents":["I want to generate a tutorial from a GitHub repo with a single CLI command","I need to configure LLM provider, output format, and file filtering without editing code","I want to run the tutorial generator in Docker for reproducible, isolated execution"],"best_for":["DevOps teams automating documentation generation in CI/CD pipelines","Individual developers generating tutorials from command line","Organizations deploying tutorial generation as a containerized service"],"limitations":["CLI argument parsing is basic — no validation of URL format or path existence before pipeline execution","Configuration precedence (CLI > env > config file) is not documented — unclear which source takes priority","Docker image includes all dependencies but may be large — no multi-stage build optimization"],"requires":["Python 3.8+ (for CLI execution)","Docker (for containerized execution)","Git CLI (for GitHub repository cloning)","LLM API credentials in environment or config file"],"input_types":["Repository URL (GitHub HTTPS) or local directory path","Output directory path","Include patterns (glob syntax, optional)","Exclude patterns (glob syntax, optional)","LLM provider and model name (optional, defaults to OpenAI)"],"output_types":["Tutorial package in output_dir (Markdown, Mermaid, Jekyll structure)","CLI exit code (0 for success, non-zero for failure)","Logging output to stdout/stderr"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-the-pocket--pocketflow-tutorial-codebase-knowledge__cap_9","uri":"capability://data.processing.analysis.language.aware.code.analysis.with.multi.language.support","name":"language-aware code analysis with multi-language support","description":"The pipeline detects programming language from file extensions and passes language context through all nodes (IdentifyAbstractions, AnalyzeRelationships, OrderChapters, WriteChapters). LLM prompts are language-aware, using language-specific terminology and patterns (e.g., 'Python decorators', 'JavaScript closures', 'Java interfaces'). Supports Python, JavaScript, Java, Go, Rust, and other common languages. Language detection is automatic and transparent to users.","intents":["I want to generate tutorials for codebases in any programming language without manual language specification","I need the LLM to understand language-specific patterns and idioms when analyzing code","I want tutorials to use language-appropriate terminology and examples"],"best_for":["Organizations with polyglot codebases needing unified documentation generation","Open-source projects supporting multiple language implementations","Teams generating tutorials for language-specific libraries or frameworks"],"limitations":["Language detection relies on file extension only — no content-based detection for ambiguous files (e.g., .js could be Node.js or browser JavaScript)","LLM prompts are generic across languages — no language-specific prompt templates for specialized patterns","Unsupported languages fall back to generic analysis — no error or warning for unsupported file types"],"requires":["Source code files with standard language extensions (.py, .js, .java, .go, .rs, etc.)","LLM with knowledge of target language (all major LLMs support common languages)"],"input_types":["Source code files with language-identifying extensions","Codebase with mixed languages (auto-detected)"],"output_types":["Language-aware abstractions and relationships","Tutorials using language-specific terminology and examples","Language metadata in output (for filtering or formatting)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":40,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","PocketFlow framework installed","LLM API credentials (OpenAI, Anthropic, or local Ollama)","Git CLI for repository cloning","Git CLI installed and in PATH (for GitHub cloning)","Read permissions on local directories","Write permissions on cache directory (.pocketflow_cache or configured path)","Sufficient disk space for cached files and LLM responses","JSON parsing library (built-in to Python)","Understanding of abstraction and relationship data model"],"failure_modes":["Sequential execution only — no parallel node processing, limiting throughput for large codebases","Shared dictionary state store has no built-in persistence or recovery — pipeline failure loses intermediate results","No conditional branching or dynamic node selection — all six nodes execute regardless of input characteristics","GitHub crawling requires public repository access — private repos need authentication token not currently exposed in CLI","Pattern matching uses simple glob syntax — no regex support for complex filtering rules","Language detection relies on file extension only — no content-based language detection for ambiguous files","Cache invalidation is manual — no automatic detection of stale cache entries when code changes","Cache is local filesystem-based — no distributed caching for multi-machine deployments or CI/CD pipelines","Cache key for files is content-hash only — moving or renaming files without content changes creates new cache entries","JSON schema is not formally documented — structure may change between versions without warning","builder identity is not verified yet","artifact is still pending review"],"rank_breakdown":{"adoption":0.6861702022213374,"quality":0.24,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.35,"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":"pending_review","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:57:11.504Z","last_commit":"2025-10-24T00:27:34Z"},"community":{"stars":12268,"forks":1397,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=the-pocket--pocketflow-tutorial-codebase-knowledge","compare_url":"https://unfragile.ai/compare?artifact=the-pocket--pocketflow-tutorial-codebase-knowledge"}},"signature":"jebdv2foB2mU+GN+EYwIMNwiH6cuSKuLRQhoTrBokDM1jh76dK3k+lL5rGGvr5eMnWPddij9QYsBxU3XsD7mCw==","signedAt":"2026-06-21T14:19:54.057Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/the-pocket--pocketflow-tutorial-codebase-knowledge","artifact":"https://unfragile.ai/the-pocket--pocketflow-tutorial-codebase-knowledge","verify":"https://unfragile.ai/api/v1/verify?slug=the-pocket--pocketflow-tutorial-codebase-knowledge","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"}}