> ## Documentation Index
> Fetch the complete documentation index at: https://docs.valyu.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Build a Patent Discovery AI Agent

> Build a patent discovery AI agent with Vercel AI SDK and Valyu

This guide walks you through using the Vercel AI SDK with Valyu's patent search API to build an AI agent capable of searching millions of patents, and analyzing IP landscapes in under five minutes.

## Why This Stack?

<CardGroup cols={2}>
  <Card title="Vercel AI SDK" icon="react">
    The fastest way to build AI apps. Stream-first design, framework-agnostic, batteries included.
  </Card>

  <Card title="Valyu Patent Search" icon="scale-balanced">
    Real-time access to millions of patents from USPTO.
  </Card>

  <Card title="Built for Speed" icon="bolt">
    Production-ready in minutes. No expensive patent databases or complex workflows.
  </Card>

  <Card title="Type-Safe" icon="shield">
    Full TypeScript support. Autocomplete everywhere. Zero runtime surprises.
  </Card>
</CardGroup>

## What You'll Build

An AI patent discovery engine that:

* Searches millions of patents across global jurisdictions
* Analyzes competitive IP landscapes
* Streams intelligent insights with patent citations

## Get Started

<Steps>
  <Step title="Installation">
    ### Install Dependencies

    ```bash theme={null}
    npx create-next-app@latest patent-ai-agent --typescript --tailwind --app
    cd patent-ai-agent
    npm install ai @ai-sdk/openai @valyu/ai-sdk
    ```

    Grab your API keys from:

    * **Valyu**: [platform.valyu.ai](https://platform.valyu.ai) - ***\$10 free credits for new signups***
    * **OpenAI**: [platform.openai.com](https://platform.openai.com)

    Add the keys to your `.env.local`:

    ```bash theme={null}
    VALYU_API_KEY=your_valyu_key_here
    OPENAI_API_KEY=your_openai_key_here
    ```
  </Step>

  <Step title="Create API Route">
    ### Build the Search Endpoint

    Create `app/api/chat/route.ts`:

    ```typescript theme={null}
    import { openai } from '@ai-sdk/openai';
    import { patentSearch } from '@valyu/ai-sdk';
    import { streamText } from 'ai';

    export async function POST(req: Request) {
      const { messages } = await req.json();

      const result = streamText({
        model: openai('gpt-5'),
        messages,
        system: `You are an expert patent analyst with access to millions of global patents.

        Guidelines:
        - Use patentSearch to find relevant patents
        - Cite patents with [Patent Number - Title](URL) format
        - Include filing/grant dates and jurisdictions
        - Identify key claims and technical innovations`,
        tools: {
          searchPatents: patentSearch(),
        },
      });

      return result.toDataStreamResponse();
    }
    ```

    **That's it!** Your agent now has access to real-time patent search.
  </Step>

  <Step title="Build the UI">
    ### Create the Chat Interface

    Replace `app/page.tsx` with:

    ```typescript theme={null}
    'use client';

    import { useChat } from 'ai/react';

    export default function PatentAgent() {
      const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat();

      return (
        <div className="flex flex-col h-screen max-w-4xl mx-auto p-4">
          <div className="flex-1 overflow-y-auto space-y-4 mb-4">
            {messages.map((message) => (
              <div
                key={message.id}
                className={`flex ${
                  message.role === 'user' ? 'justify-end' : 'justify-start'
                }`}
              >
                <div
                  className={`rounded-lg px-4 py-2 max-w-2xl ${
                    message.role === 'user'
                      ? 'bg-blue-500 text-white'
                      : 'bg-gray-100 text-gray-900 prose prose-sm'
                  }`}
                >
                  <div
                    dangerouslySetInnerHTML={{
                      __html: message.content.replace(
                        /\[([^\]]+)\]\(([^)]+)\)/g,
                        '<a href="$2" target="_blank" class="text-blue-600 underline">$1</a>'
                      ),
                    }}
                  />
                </div>
              </div>
            ))}
          </div>

          <form onSubmit={handleSubmit} className="flex gap-2">
            <input
              value={input}
              onChange={handleInputChange}
              placeholder="Search patents, analyze prior art, or explore IP landscapes..."
              className="flex-1 px-4 py-2 border rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
              disabled={isLoading}
            />
            <button
              type="submit"
              disabled={isLoading}
              className="px-6 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-300"
            >
              {isLoading ? 'Searching...' : 'Search'}
            </button>
          </form>
        </div>
      );
    }
    ```

    You're free to design the UI in whatever way works best for your use case.
  </Step>

  <Step title="Run Your Agent">
    ### Start Discovering

    ```bash theme={null}
    npm run dev
    ```

    Try the following queries when you run your agent:

    * "Find prior art for neural network training optimization techniques"
    * "Analyze the patent landscape for solid-state battery technology"
    * "What patents does Apple hold in augmented reality displays?"
    * "Freedom to operate analysis for CRISPR gene editing tools"

    Your agent searches millions of patents and delivers comprehensive IP insights instantly.
  </Step>
</Steps>

Here are four production-ready agentic apps you can build using patent search:

### 1. Prior Art Search Assistant

Automate comprehensive prior art searches for patent applications:

```typescript theme={null}
import { patentSearch } from '@valyu/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai('gpt-5'),
    messages,
    system: `You are a prior art search specialist. Your role:

    1. Search comprehensively across patent databases and literature
    2. Identify most relevant prior art by technical similarity
    3. Analyze claims overlap and novelty assessment
    4. Extract key technical features and embodiments
    5. Map invention to IPC/CPC classification codes
    6. Provide detailed invalidity analysis

    Always organize findings by: relevance ranking, claim mapping, technical differentiation.`,
    tools: {
      priorArt: patentSearch(),
    },
  });

  return result.toDataStreamResponse();
}
```

**Example queries:**

* "Prior art search for AI-powered protein structure prediction methods"
* "Find patents that disclose quantum error correction using surface codes"
* "Identify prior art for autonomous vehicle path planning algorithms"

### 2. Freedom to Operate (FTO) Analysist

Assess patent infringement risks before product launch:

```typescript theme={null}
import { patentSearch } from '@valyu/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai('gpt-5'),
    messages,
    system: `You are an FTO analysis expert. Focus on:

    1. Identifying active patents in target jurisdictions
    2. Claim-by-claim infringement analysis
    3. Assessing patent validity and enforceability
    4. Highlighting design-around opportunities
    5. Tracking patent expiration dates
    6. Flagging high-risk blocking patents

    Provide: risk assessment matrix, key claims analysis, geographic coverage, mitigation strategies.`,
    tools: {
      patents: patentSearch(),
    },
  });

  return result.toDataStreamResponse();
}
```

**Example queries:**

* "FTO analysis for launching a smartwatch with ECG monitoring in US and EU"
* "Identify blocking patents for mRNA vaccine delivery systems"
* "Design-around opportunities for wireless charging technology"

### 3. Competitive Patent Intelligence

Monitor competitors' IP strategies and innovation trends:

```typescript theme={null}
import { patentSearch } from '@valyu/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai('gpt-5'),
    messages,
    system: `You are a patent intelligence analyst. Track:

    1. Competitor patent filing trends and strategies
    2. Emerging technology areas by assignee
    3. Key inventors and research directions
    4. Patent family growth and geographic expansion
    5. Licensing and litigation activities
    6. White space opportunities in IP landscape

    Identify: technology shifts, competitive threats, collaboration patterns, acquisition targets.`,
    tools: {
      competitorIP: patentSearch(),
    },
  });

  return result.toDataStreamResponse();
}
```

**Example queries:**

* "Analyze Samsung's recent patent activity in foldable display technology"
* "Compare AI chip patent portfolios: NVIDIA vs Intel vs AMD"
* "Track pharmaceutical companies' antibody engineering patent trends"

### 4. Patent Portfolio Optimizer

Generate insights for strategic patent portfolio management:

```typescript theme={null}
import { patentSearch } from '@valyu/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { generateObject } from 'ai';

export async function POST(req: Request) {
  const { company, technology } = await req.json();

  const { object } = await generateObject({
    model: openai('gpt-5'),
    prompt: `Analyze patent portfolio strategy for ${company} in ${technology}`,
    tools: {
      search: patentSearch(),
    },
  });

  return Response.json(object);
}
```

**Example queries:**

* "Portfolio gap analysis for automotive LiDAR technology"
* "Identify underutilized patents for licensing opportunities"
* "Strategic recommendations for 5G infrastructure patent portfolio"

Each of these agents can be built in under 30 minutes and provides immediate value to patent attorneys, IP managers, R\&D teams, and innovation strategists.

***

## Real-World Application

Want to see Valyu's patent search in action? Check out our production demo:

<Card title="Valyu Patent AI" icon="file-certificate" href="https://patents.valyu.ai">
  Experience a full-featured patent research assistant powered by Valyu's patent search. Discover prior art, analyze IP landscapes, and get actionable patent insights across millions of global patents.
</Card>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Valyu AI SDK Playground" icon="book" href="https://ai-sdk.valyu.ai">
    Explore Valyu AI SDK features
  </Card>

  <Card title="Valyu API Reference" icon="code" href="/api-reference/endpoint/deepsearch">
    Full API documentation and parameters
  </Card>

  <Card title="Example Apps" icon="github" href="/example-apps">
    Open source example applications
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/umtmSsppRY">
    Get help from the Valyu community
  </Card>
</CardGroup>

***