Enterprise-Grade Memory Agents for Patent Processing with Deep Lake

activeloop · Legal · 2023 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Patent search and generation

Activeloop built PatentGPT to search, answer questions over, and generate patent content from an 80-million-document corpus where manual keyword search and patent drafting take weeks.

Constraints:

• The corpus contains about 80 million patents and about 600,000 patent filings per year.
• Manual patent generation takes two to four weeks on average.
• Traditional USPTO keyword search requires manual document review.
• Different patent tasks require specialized agents such as claim search, abstract search, question answering, and generation.
• Retrieval quality and memory efficiency are critical before fine-tuning language models.

Architecture

PatentGPT combines Deep Lake storage, embeddings, memory APIs, fine-tuned models, and a meta-agent that routes user queries to specialized agents for claim search, abstract search, question answering, and patent generation. The system deploys on AWS and Intel infrastructure and uses Deep Memory to improve vector recall without changing the vector-search interface.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  user-query["User query"] --> meta-agent-router["Meta-agent router"]
  meta-agent-router --> claim-search-agent["Claim search agent"]
  meta-agent-router --> abstract-search-agent["Abstract search agent"]
  meta-agent-router --> question-answering-agent["Question answering agent"]
  meta-agent-router --> patent-generation-agent["Patent generation agent"]
  claim-search-agent --> deep-lake-memory["Deep Lake memory"]
  abstract-search-agent --> deep-lake-memory
  question-answering-agent --> deep-lake-memory
  patent-generation-agent --> fine-tuned-models["Fine-tuned models"]
  deep-lake-memory --> deep-memory-recall-layer["Deep Memory recall layer"]

Components

Data flow

A user query enters the meta-agent, which decides which specialized patent agents to use; those agents query Deep Lake/Deep Memory, embeddings, and fine-tuned models for claim search, abstract search, question answering, or generation, then return patent-specific output.

Why this architecture

Activeloop uses specialized memory agents because patents are not one problem: claim search, abstract search, QA, and generation need different retrieval and generation behaviors over a very large corpus.

Models used: PatentGPT · Deep Lake · Deep Memory · Fine-tuned embedding models · Fine-tuned language models · AWS · Intel

Scale

• The patent domain has about 600,000 patent filings per year.
  “you have about 600 000 patents Fields every year”transcript, stated
• The corpus includes about 80 million documents.
  “in total you have about 80 million across the whole club”transcript, stated
• Manual patent generation takes two to four weeks on average.
  “it takes in average two to four weeks to generate these payments”transcript, stated
• Deep Memory is reported to improve recall by five to ten percent.
  “you can actually get up to five to ten percent Improvement on your recall”transcript, stated

Alternatives considered (roads not taken)

Use old-school USPTO keyword search.

Rejected because: Users must manually review document lists and generate patent content themselves.

Use one general agent for every patent task.

Rejected because: The presenter says agents should be well scoped and solve specific domains.

Fine-tune the LLM before fixing retrieval recall.

Rejected because: The talk says retrieval accuracy/recall should be handled before later fine-tuning concerns.

Patterns

multi-agent-orchestration (orchestration)

A meta-agent routes queries to specialized patent agents.

agent-memory (memory)

Deep Lake and Deep Memory provide the memory layer for patent retrieval and agent work.

fine-tuning-adaptation (model-ops)

The system uses models fine-tuned on the patent dataset for better task behavior.

Tradeoffs

Use scoped specialist agents.

Chose Claim, abstract, QA, and generation agents routed by a meta-agent. over One general patent assistant..

Rationale: Patent workflows are structurally different and benefit from task-specialized behavior.

Improve retrieval recall with Deep Memory.

Chose Recall layer on top of vector search. over Changing the whole vector search interface or immediately fine-tuning LLMs..

Rationale: The presenter says recall gains matter when RAG works only part of the time and needs to move above 80 or 90.

Gotchas (what bit them)

Patent work is not a single search problem.

Root cause: Users may need claims, abstracts, question answering, or generation, each with different behavior.

Resolution: Route through specialized agents by task.

Manual search does not scale to large patent corpora.

Root cause: Keyword search returns lists of documents for humans to review.

Resolution: Use memory agents over embeddings and patent-specific models.

Fine-tuning before retrieval quality can waste effort.

Root cause: The LLM only performs as well as the retrieved context it receives.

Resolution: Improve recall and context quality first, then tune embeddings or LLMs.

Evaluation

Activeloop evaluates through recall at top-k, retrieval accuracy, and task-specific patent-agent performance before considering further model or embedding fine-tuning.

Metrics: Recall at 10 / top-k recall · Five to ten percent recall improvement · RAG success moving from 70% toward 80-90% · Patent task routing quality

Outcomes

• PatentGPT routes patent tasks to specialized memory agents.
• Deep Memory improves vector recall without changing the vector search interface.
• The architecture supports patent search, QA, abstract work, claim search, and generation over a very large corpus.

The source cites roughly 600,000 patent filings per year, about 80 million documents, and a two-to-four-week manual generation timeline.