Patent Infringement Check App

This repository contains a full-stack application for checking patent infringement against a company's products. The app features a backend built with Node.js and a frontend built using React.js. The application uses a language model API to determine potential patent infringements.

Table of Contents

1. Installation
2. User Manual
3. System Architecture Diagram
4. Core Functionality
5. Project Development Plan

Installation

Prerequisites

• Docker and Docker Compose installed.
• Node.js (if building locally without Docker).

Steps to Install and Run

1. Update the OpenAI API Key:

   • Open the backend/app/config.js file.
   • Replace the value your_openai_api_key_here with your OpenAI API key.

2. Build and Run the Application Using Docker Compose:

   • Run the following command to build the backend and frontend services:

     docker-compose build

   • Start the application:

     docker-compose up

3. Access the Application:

   • Frontend: Visit http://localhost:3000 to access the application.
   • Backend: API endpoints are available at http://localhost:3001.

Optional: Running Locally without Docker

• Navigate to the backend and frontend directories and run npm install in both.
• Start the backend:

  cd backend
  npm start

• Start the frontend:

  cd frontend
  npm start

User Manual

Accessing the App

• Homepage: When you first visit the homepage, you will see a form to enter a Patent ID and a Company Name.

Running an Infringement Check

1. Enter Patent ID: Type in the patent ID you want to check.
2. Enter Company Name: Type in the company name whose products you wish to analyze.
3. Submit the Form: Click on the "Check Infringement" button.
4. View Results: After submitting, the app will display the top two products that potentially infringe on the patent, including explanations, relevant claims, and infringement likelihood.

System Architecture Diagram

The system architecture includes the following components:

---
title: AI Patent Infringement Check App
---
flowchart TB
    subgraph Client["Client Layer"]
        Browser["User's Browser"]
        Frontend["React Frontend (Dockerized)"]
    end

    subgraph Backend["Server Layer (Dockerized)"]
        NodeBackend["Node.js Backend"]
        Template["OpenAI Prompt Template"]
        
        subgraph Processing["Data Processing"]
            InputHandler["Patent ID & Company Input Handler"]
        end
    end

    subgraph External["External Services"]
        OpenAI["OpenAI API"]
    end

    Browser --> Frontend
    Frontend --> NodeBackend
    NodeBackend --> InputHandler
    InputHandler --> Template
    Template --> InputHandler
    InputHandler --> NodeBackend
    NodeBackend --Prompt with Patent & Company Info--> OpenAI
    OpenAI --Response Standard JSON--> NodeBackend
    NodeBackend --> Frontend

    classDef docker fill:#e1f5fe,stroke:#01579b
    classDef process fill:#e8f5e9,stroke:#2e7d32
    classDef External fill:#fff3e0,stroke:#e65100
    
    class Frontend,NodeBackend docker
    class InputHandler,Template process
    class OpenAI,Standard External

Loading

1. React Frontend: Provides a responsive user interface where users can input patent IDs and company names, and view results.
2. Node.js Backend: Manages incoming requests, interacts with the local dataset, and uses OpenAI API for analysis.
   1. OpenAI prompt template - It's a template for the OpenAI API to generate static responses as expected.
3. Integrationn of OpenAI API: Processes patent and product data to determine potential infringement and provides analysis.
   1. OpenAI Response Standardization - Standardizes the response from the OpenAI API as JSON based on the prompt template.

Core Functionality

1. Input Patent ID and Company Name: Users can input a patent ID and the name of a company whose products they want to check.
2. Run Patent Infringement Analysis: The backend uses the patent details and company products to generate an infringement analysis via the OpenAI API.
3. Return Top Two Infringing Products: The analysis identifies the top two products likely infringing on the patent and details which claims are at risk.
4. Dockerized Deployment: Both frontend and backend are containerized using Docker, simplifying installation and deployment.

Feel free to reach out for any questions!

Project Development Plan

Project Setup

• Initialize Project Structure:
  • Set up a repository and initialize Node.js (or Python) for the backend.
  • Set up the frontend framework and create necessary components.
• Docker Configuration:
  • Write a Dockerfile for both frontend and backend services.
  • Use docker-compose to orchestrate these services together.

Backend Development

• Set Up API Endpoints:
  • Create an endpoint to receive user input (/infringement-check), which will accept patent ID and company name.
  • Create an endpoint for retrieving saved analysis reports (/saved-reports).
• Data Handling:
  • Load the patents.json and company_products.json files to extract the necessary data.
  • Develop logic to fuzzy match company names using a library like fuzzywuzzy (Python) or similar.
• Infringement Analysis Logic:
  • Integrate with the LLM (via API) to generate explanations and determine the infringement likelihood.
  • Implement a simple caching mechanism to reduce repetitive API calls for the same analysis.
• Save Reports Functionality:
  • Create a report-saving endpoint (/save-report) to persist infringement results. Store saved reports in a file or use a lightweight database like SQLite.

Frontend Development

• UI for Input:
  • Develop a form where users can enter the patent ID and company name.
  • Add basic validation to ensure the user has entered all required fields.
• Results Display:
  • Design a UI component to display the infringement analysis, including product details and relevant claims.
  • Ensure that the results are easy to read and well formatted.
• Saved Reports Page:
  • Create a page to view previously saved reports. Display them in a user-friendly way.

Integration and Testing

• LLM API Integration:
  • Integrate the backend with the LLM API for performing patent analysis.
  • Handle any API rate limits or errors gracefully to avoid breaking the user experience.
• End-to-End Testing:
  • Test the complete flow from frontend to backend, ensuring that inputs are correctly processed and results are displayed.
  • Write unit tests for core functionality, including API calls and data processing.

Dockerization and Hosting (Bonus)

• Dockerize the Application:
  • Write separate Dockerfiles for both frontend and backend services.
  • Use docker-compose to create a unified environment.
• Hosting (Bonus):
  • Deploy the app on a hosting platform like AWS, DigitalOcean, or use Heroku for simplicity.
  • Ensure that the web server has all necessary configurations to run the containerized app.

README and Documentation

• Write README.md:
  • Include setup instructions, how to run the app using Docker, and any assumptions made.
  • Provide an overview of the core functionalities and how to use the app.

Additional Features (Bonus)

• User Input Parsing (Bonus):
  • Implement fuzzy matching of company names to handle slight differences or typos in user input.
• Saving and Viewing Reports (Bonus):
  • Add an option for users to save analysis results and view them later.
  • Store saved reports in JSON or a simple database.

Final Review and Polishing

• Code Review: Perform a final review of the code, refactoring where necessary.
• UI/UX Improvements: Improve the UI for better user experience, such as adding loading indicators during analysis.
• Bug Fixes: Address any discovered bugs, especially those that could break user input or analysis flows.