Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Elite GitHub Gem Seeker Pro: AI Tool Finder

    1

    Discover, audit, and execute battle-tested GitHub repositories and CLI tools for production workflows.

    $14.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Elite GitHub Gem Seeker Pro: AI Tool Finder

    Elite GitHub Gem Seeker Pro: AI Tool Finder

    Example session with this skill installed

    We are building a proprietary, closed-source B2B SaaS platform in Python that needs to extract complex multi-column financial tables from uploaded PDFs and convert them into Markdown or Pandas DataFrames. Since this will be embedded directly into our commercial backend and we cannot open-source our proprietary code, compare the top battle-tested GitHub gems for this task, audit their licenses carefully, and give me the best production recommendation.

    • Read your context and instructions
    • Compiled the elite github gem

    Executive Recommendation: Use

    pdfplumber (MIT) as your primary engine for born-digital financial PDFs, with

    Docling (MIT) as a containerized fallback for scanned or layout-heavy files. Both are permissively licensed and safe to embed in a closed-source backend.

    PyMuPDF and

    Marker, which often top "best PDF extractor" lists, are blocked for your use case.

    I did not query live GitHub data in this session. Star counts are Pantheon baselines marked (est.), and you should verify licenses on the current release tags before shipping.

    7-Column Gem Scorecard

    RepositoryStars & TierLanguage / FootprintLicense (Code + Weights)Maintenance StatusTechnical Strengths & Trade-offsVerdict
    jsvine/pdfplumber🛡️ Battle-Tested, ~6k+ ⭐ (est.)Python, Tier 2 (pure Python on pdfminer.six)MIT, no ML weightsActively maintained (verify last release)Precise control over lines and text strategies, per-cell bounding boxes, and fast, deterministic output. It needs per-document-family tuning and has no OCR.🟢 Primary
    DS4SD/docling💎 Diamond, ~25k+ ⭐ (est.)Python, Tier 3 (PyTorch, layout and table models)MIT code. Model weights are separately published, so audit each checkpoint's card.Very active (IBM-originated, LF AI & Data)Strong on complex or borderless tables and scanned pages, with native export_to_dataframe() and export_to_markdown(). It is heavy and slower, and output is probabilistic.🟡 Fallback / Caveat
    pikepdf/Camelot (camelot-dev/camelot)🛡️ Battle-Tested, ~3k+ ⭐ (est.)Python, Tier 2 to 3MIT code, but older versions depend on Ghostscript (AGPL)Check the current releaseGood lattice/stream modes. The Ghostscript backend is a license trap, so use only a pypdfium2 backend (Apache-2.0/BSD) if you pick it.🟡 Fallback / Caveat
    pymupdf/PyMuPDF💎 Diamond, ~25k+ ⭐ (est.)C (MuPDF) with Python bindingsAGPL-3.0, or a paid Artifex commercial licenseVery activeFast and accurate with a good find_tables(), but linking it into a proprietary backend triggers AGPL obligations.🔴 Blocked / Paid License Required
    VikParuchuri/marker💎 Diamond, ~25k+ ⭐ (est.)Python, Tier 3 (Torch)GPL-3.0 code plus restricted (revenue-capped) weightsVery activeExcellent Markdown output, but both the code and weight licenses conflict with closed-source SaaS.🔴 Blocked (License)

    Deep License & Supply-Chain Audit

    pdfplumber: The code is MIT. Its core dependency pdfminer.six is MIT, Pillow is HPND (permissive), and pypdfium2 (used for page images) is Apache-2.0/BSD-3. There are no model weights, so it is clean at all three layers.

    Docling: The code is MIT, but its dependency tree is large. Run pip-licenses on your lockfile and check each model card (layout, TableFormer, OCR) for commercial terms. OCR engines vary: RapidOCR and EasyOCR are Apache-2.0, while Tesseract is Apache-2.0 but a system dependency.

    Camelot: The code is MIT, but a Ghostscript backend (AGPL) would pull AGPL software into your stack. Do not use it unless you pin a pdfium-based backend and confirm that in the lockfile.

    PyMuPDF: AGPL-3.0 covers network use, so serving it from a SaaS backend triggers disclosure unless you buy the Artifex license. pymupdf4llm inherits this.

    Marker: GPL-3.0 code plus restricted weights fails both the code layer and the weights layer for closed-source use.

    I can't give legal advice. Have counsel review the final dependency tree, particularly Docling's model checkpoints.

    Zero-Pollution Quickstart

    uv venv && source .venv/bin/activate
    uv pip install pdfplumber pandas tabulate
    
    import pdfplumber, pandas as pd
    
    # Ruled financial tables: use "lines". Borderless tables: switch to "text".
    SETTINGS = {
        "vertical_strategy": "lines",
        "horizontal_strategy": "lines",
        "snap_tolerance": 3,
        "intersection_tolerance": 5,
    }
    
    def extract_tables(path: str, settings: dict = SETTINGS) -> list[pd.DataFrame]:
        dfs = []
        with pdfplumber.open(path) as pdf:
            for page_no, page in enumerate(pdf.pages, start=1):
                for t in page.extract_tables(table_settings=settings):
                    if not t or len(t) < 2:
                        continue
                    df = pd.DataFrame(t[1:], columns=t[0])
                    df.attrs["page"] = page_no
                    dfs.append(df)
        return dfs
    
    if __name__ == "__main__":
        for df in extract_tables("report.pdf"):
            print(f"--- page {df.attrs['page']} ---")
            print(df.to_markdown(index=False))
    

    Fallback for scanned or borderless pages, run in a container:

    from docling.document_converter import DocumentConverter
    
    result = DocumentConverter().convert("report.pdf")
    for table in result.document.tables:
        df = table.export_to_dataframe(doc=result.document)
        md = table.export_to_markdown(doc=result.document)
    

    Production Gotchas

    Routing: Detect whether a page has a text layer (page.extract_text() returns non-empty text). If it doesn't, send the file to the Docling worker instead of pdfplumber.

    Isolation: Run Docling in its own container with memory limits (for example, 8 GB), a per-document timeout, and GPU or CPU pinning. Never run it in the web process. Wrap pdfplumber calls in a subprocess or worker with a timeout too, since malformed PDFs can hang parsers.

    Financial-table quirks: Merged header cells, parenthesized negatives like (1,234), footnote markers, and multi-page tables split across pages all need post-processing. Normalize numbers explicitly and keep a validation step such as totals reconciliation.

    Untrusted uploads: Treat PDFs as hostile input. Enforce file size and page limits, and consider qpdf (Apache-2.0) to sanitize or linearize files before parsing.

    Pin versions and re-run license scans on every dependency bump. Camelot's and Docling's dependency graphs change between releases.

    Accuracy: Build a small gold-standard set of your own PDFs and benchmark both engines on it before committing. Table-extraction quality varies heavily with document family.

    💎 Powered by Open Source: pdfplumber

    • Repository: https://github.com/jsvine/pdfplumber
    • Tier & Traction: 🛡️ Battle-Tested Tier | ~6k+ ⭐ (est.) | Actively Maintained
    • License: MIT (code and dependencies, no model weights). Commercial friendly.

    Why This Gem Won: It is the only top-tier PDF table extractor with a fully permissive stack, no ML weights, and deterministic, tunable output that is safe to embed in closed-source software.

    *

    Support the Maintainers: If this saved you hours of custom coding, consider giving the repository a ⭐ star on GitHub!

    *

    Automate This Workflow: Reply

    "Package as Skill" or

    "Build Wrapper Script" and I will compile this exact configuration into a reusable, one-command skill or hardened production module for your workflow.

    💎 Also Powering the Fallback: Docling

    • Repository: https://github.com/DS4SD/docling
    • Tier & Traction: 💎 Diamond Tier | ~25k+ ⭐ (est.) | Actively Maintained
    • License: MIT code. Verify each model checkpoint's license before commercial use.

    If you share a sample PDF, I can tune the pdfplumber settings against it and show you the actual extraction output.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop writing brittle custom code from scratch. Elite GitHub Gem Seeker Pro is an enterprise-grade AI agent skill that discovers, vets, and executes battle-tested open-source GitHub repositories, CLI tools, and libraries. It performs rigorous multi-vector code and model-weight license audits (safely navigating MIT, Apache, GPL, and AGPL copyleft traps), enforces zero-pollution sandboxed execution (uvx, npx), and automates complex media processing, document parsing, web scraping, and DevOps workflows instantly. Built for developers, AI engineers, and automated software pipelines.

    Execution depends on sandbox environment constraints and available system binaries. Star counts are estimated if live API access is restricted. Model weight licenses require manual verification.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 29 days ago

    Requires

    Python
    yt-dlp
    uv (Python tool runner)
    trafilatura

    Permissions

    Browser
    Network Access
    Read Files
    Write Files
    Listed29 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the discovery and secure execution of high-quality GitHub repositories, preventing developers from wasting time writing custom code for tasks that already have battle-tested open-source solutions. It specifically solves the risks of using unmaintained code or accidentally introducing incompatible licenses into commercial projects.

    The skill uses a 6-Point Pro Vetting Protocol that audits repository maintenance, star velocity, community traction, and a three-layer license check (including transitive dependencies and AI weights) to ensure tools are production-ready.

    To maintain system integrity, the skill prioritizes isolated execution environments using runners like uvx, npx, pipx, and Docker, ensuring that new tools don't conflict with your host system's existing dependencies.

    Elite GitHub Gem Seeker Pro is compatible with any AI agent or platform that supports tool-calling and has access to a terminal or sandbox environment for executing CLI commands.

    You receive the core discovery engine, the 7-column architectural decision matrix generator, the automated vetting protocols, and access to the 'Pantheon' of pre-vetted tool configurations for immediate deployment.

    The skill is designed to handle common data and media tasks like PDF parsing with Docling, document conversion via Pandoc, and high-speed media processing with FFmpeg, provided the necessary system-level binaries are available in your environment.

    New in Prompt & Skill Engineering