A full-pipeline patent platform that takes inventors from idea to filing-ready draft. Search prior art across multiple databases, analyze patentability, generate complete patent applications, and export documents ready for attorney review or filing.

Built for Memoriant — self-hosted, model-agnostic, and distributable.

Describe Invention  ──>  Prior Art Search  ──>  Analysis  ──>  Draft Application  ──>  Review  ──>  Export

Patent Search

• Multi-provider: PatentsView (free), USPTO Open Data Portal (free), Google Patents via SerpAPI (paid, opt-in)
• Multi-strategy: keyword, CPC classification, citation chain, inventor/assignee, date range
• Follows the USPTO 7-step prior art search methodology
• Parallel search with result deduplication and relevance scoring

Patent Analysis

• Subject matter eligibility (35 USC 101)
• Novelty pre-screening (35 USC 102)
• Obviousness assessment (35 USC 103)
• Claims definiteness (35 USC 112(b))
• Specification enablement (35 USC 112(a))
• Formalities compliance (MPEP 608)

Patent Drafting

• USPTO provisional application
• USPTO non-provisional (utility) application
• PCT international format
• Multiple embodiments with broad-to-narrow fallback claims
• Application Data Sheet (ADS) generation
• 12-month provisional deadline tracking

Model-Agnostic AI

• Claude API (default, optimized for Opus 4.6 with extended thinking)
• Ollama, vLLM, LM Studio — any OpenAI-compatible endpoint
• Free by default, paid search sources opt-in

                    ┌─────────────────────────────┐
                    │     Delivery Layer           │
                    │  ┌─────────┐  ┌───────────┐ │
                    │  │ FastAPI │  │ Claude    │ │
                    │  │   API   │  │ Code      │ │
                    │  │         │  │ Skills    │ │
                    │  └────┬────┘  └─────┬─────┘ │
                    └───────┼─────────────┼───────┘
                            │             │
                    ┌───────▼─────────────▼───────┐
                    │     Core Library             │
                    │  ┌──────────────────────┐   │
                    │  │  Pipeline            │   │
                    │  │  Orchestrator        │   │
                    │  └──────────┬───────────┘   │
                    │  ┌──────┐ ┌┴─────┐ ┌─────┐ │
                    │  │Search│ │Analy-│ │Draft│ │
                    │  │      │ │sis   │ │     │ │
                    │  └──┬───┘ └──┬───┘ └──┬──┘ │
                    │     │        │        │     │
                    │  ┌──▼────────▼────────▼──┐  │
                    │  │   Domain Models        │  │
                    │  └───────────────────────┘  │
                    └─────────────┬───────────────┘
                                  │
                    ┌─────────────▼───────────────┐
                    │     Infrastructure           │
                    │  ┌─────┐ ┌───────┐ ┌──────┐ │
                    │  │ LLM │ │Storage│ │Search│ │
                    │  │     │ │       │ │ APIs │ │
                    │  └─────┘ └───────┘ └──────┘ │
                    └─────────────────────────────┘

Modular core, multiple frontends. The core library handles all patent logic. The FastAPI web service and Claude Code skills are just different ways to access it.

git clone https://github.com/NathanMaine/memoriant-patent-platform.git
cd memoriant-patent-platform
cp .env.example .env
# Edit .env with your API keys
docker compose up

Open http://localhost:3000 for the web UI, http://localhost:8080 for Supabase Studio.

# Install the skills into Claude Code
cp -r skills/ ~/.claude/skills/patent/
# Configure your provider
claude /patent-config
# Run a search
claude /patent-search "wireless power transfer for medical implants"

pip install memoriant-patent-core

from memoriant_patent_core import Pipeline, Config

config = Config(llm_provider="claude", anthropic_api_key="sk-...")
pipeline = Pipeline(config)
result = pipeline.run("A system for adaptive wireless power transfer...")

# .env.example

# LLM Provider (Claude is default)
LLM_PROVIDER=claude
ANTHROPIC_API_KEY=
CLAUDE_MODEL=claude-opus-4-6
CLAUDE_EXTENDED_THINKING=true

# Alternative LLM Providers (optional)
# OLLAMA_BASE_URL=http://localhost:11434
# VLLM_BASE_URL=http://localhost:8000

# Search Providers — Free (default on)
PATENTSVIEW_API_KEY=

# Search Providers — Paid (opt-in)
# SERPAPI_KEY=

Free search sources are on by default. Paid sources require explicit API key configuration. No surprise costs.

The Docker stack includes Supabase (auth + database + storage + realtime), Qdrant (vector search), FastAPI (backend), and React (frontend). All containers run hardened: non-root, read-only filesystem, dropped capabilities, network segmentation.

• Design specification (Brain Trust reviewed)
• Phase 1: Core Foundation — models, LLM abstraction, storage, Docker infrastructure
• Phase 2: Search & Analysis — PatentsView, USPTO, analysis modules (101-112)
• Phase 3: Drafting & Pipeline — application generation, pipeline orchestrator, API
• Phase 4: Frontend & Skills — React web app, Claude Code skills & agents

This platform is a research and drafting aid, not a substitute for professional legal counsel. Patent law is complex, and the quality of your patent protection depends on experienced legal guidance.

• Always have a qualified patent attorney review applications before filing
• AI-generated analysis may not catch all issues an experienced examiner would raise
• Generated DOCX documents should be validated against USPTO Patent Center before filing
• This tool does not provide legal advice

MIT

Built by Nathan Maine