Description:FIELD OF INVENTION
The present invention relates to automated software documentation systems. More particularly, it pertains to a method for generating structured product documentation using large language models (LLMs) and reverse engineering of development artifacts

BACKGROUND
The current software systems and development environments generate large volumes of technical data, which include code changes, project tickets, informal discussions, and internal design notes. Although this data is valuable, further converting it into well-structured and high-quality documentation continues to be a tedious and error-prone process. As development teams grow and workflows become faster, manual documentation methods often result in incomplete, outdated, or inconsistent outputs, which creates obstacles in onboarding, compliance, and system understanding. Moreover, with the adoption of agile and Development and Operations (DevOps) approaches, the volume of unstructured artifacts has grown significantly, making it increasingly difficult to maintain accurate and up-to-date documentation.
In order to manage this complexity, several organizations rely on different documentation tools and methods. These usually involve manually collecting and organizing information, using static templates, or applying rule-based automation scripts. While these approaches provide some level of assistance, they do not adapt well to the fast-paced and dynamic nature of modern development workflows. The documentation created through these methods often lacks clarity, consistency, and the ability to trace back decisions or changes. Even tools that attempt to automate documentation usually depend on fixed formats and are unable to connect related artifacts like linking a Git commit to a Jira task or a conversation in Slack. As a result, current solutions are not only time-consuming but also fall short in producing detailed, traceable, and up-to-date documentation.
The present invention overcomes these limitations by offering a complete system for automated product documentation using large language models (LLMs) and reverse engineering of development artifacts. It introduces a unique pipeline that collects and classifies inputs like Git commits, Jira tickets, Slack conversations, and internal notes, and then maps them into a dynamic knowledge graph. This graph further helps to generate clear, structured, and human-readable documentation, which includes architecture diagrams, feature breakdowns, and requirement traceability. Unlike traditional tools, this system understands the context, supports continuous updates, and creates traceable links between code, requirements, and related decisions, thereby turning scattered development data into living documentation that evolves with the project.

PRIOR ARTS
For instance, US7568184B1 discloses a system for generating software documentation by extracting and formatting information from structured sources such as application source code, Web Services Description Language, (WSDL) files, and configuration data. While it automates documentation, it relies heavily on predefined file types and format-specific processing. In contrast, the present invention uses large language models (LLMs) and a typed knowledge graph to semantically analyze both structured and unstructured development artifacts, enabling evolving, context-rich documentation with traceable relationships.
US6873992B1 describes a system for automated document generation and negotiation through template-based customization, primarily for legal and professional documents. Although it streamlines document creation, it is driven by user input and is limited to predefined templates. The present invention differs by autonomously generating technical documentation through reverse engineering of software development artifacts, without requiring manual customization or static templates.
US11227095B2 relates to dynamic document generation using reusable content objects and templates triggered by external data sources. This approach is suitable for structured and repeatable documents but lacks semantic analysis or contextual reasoning. In contrast, the present invention leverages fine-tuned LLMs and graph traversal logic to create documentation that adapts to ongoing changes in development workflows and reflects interrelated decisions, code changes, and requirements.
The present invention provides a system and method that tackles these challenges by using large language models (LLMs) and Common Vulnerabilities and Exposures (CVE)-based intelligence to simulate realistic attack scenarios. It helps in automatically identifying vulnerabilities, role-based access issues, and semantic inconsistencies in software systems, thereby reducing the need for manual testing and supporting continuous, context-aware security validation.

DEFINITIONS
“Automated Product Documentation System” refers to a system that utilizes large language models (LLMs) and reverse engineering of software development artifacts to generate intelligent, structured documentation for software products.
“Large Language Models (LLMs)” refers to advanced natural language processing models used to extract, classify, and generate natural language content from software development artifacts.
“Reverse Engineering of Project Artifacts” refers to the process of analyzing and interpreting development artifacts, such as Git commits, Jira tickets, Slack messages, and internal documentation to extract context, relationships, and technical insights.
“Development Artifacts” refers to project-related data generated during the software development lifecycle, including but not limited to commits, branches, tickets, sprints, threads, and design notes.
“Intent-Oriented Artifact Classification” refers to the process of determining the intent behind each artifact using large language models and categorizing it into types such as requirement, feature, design decision, implementation detail, or bug fix.
“Dynamic Knowledge Graph” refers to a graph-based structure where nodes represent entities like commits, features, documents, and tickets, and edges represent relationships such as "implements", "discussed in", or "derived from", and which supports temporal updates and traversal queries.
“Reverse Traceability Engine” refers to the component that enables bi-directional traceability between documentation elements and underlying development artifacts, allowing for human-readable linkage and contextual understanding.
“Narrative and Diagram Generation” refers to the generation of executive summaries, technical descriptions, and visual architecture diagrams (e.g., Mermaid or PlantUML diagrams) using the knowledge graph and intent-classified artifacts.
“Incremental Learning and Regeneration” refers to the process where new artifacts trigger selective updates in the knowledge graph and regenerate only the impacted sections of documentation, while preserving historical context for version comparison.
“Living Documentation” refers to documentation that evolves in real-time with the underlying software project, automatically reflecting changes in commits, features, and design decisions as they occur.

OBJECTS OF THE INVENTION
The primary object of the present invention is to provide a system and method for automatically generating technical product documentation using large language models (LLMs) and reverse engineering of software development artifacts.
Another object of the invention is to ingest project artifacts from various platforms such as Git, Jira, Slack, and document repositories.
Yet another object of the invention is to extract and classify intents from each artifact using large language models.
Yet another object of the invention is to construct a dynamic knowledge graph that maps relationships between requirements, design decisions, code components, and documentation.
An additional object of the invention is to generate human-readable documentation and diagrams based on the graph and update the documentation incrementally as the underlying artifacts evolve.

SUMMARY
Before the present invention is described, it is to be understood that the present invention is not limited to specific methodologies and materials described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention.
The present invention relates to an automated product documentation system that generates technical documentation with minimum human intervention. The system is designed to create structured and intelligent documentation by reverse-engineering software development artifacts. It uses large language models (LLMs) along with project artifacts such as Git commits, Jira tickets, Slack messages, and internal documentation. The invention enables contextual understanding, traceability, and continuous updates through an efficient and scalable documentation pipeline. The system consists of an ingestion layer , an LLM pipeline, a graph store, a traceability engine, a document renderer, and a change detector.
According to an aspect of the present invention, the invention provides a comprehensive system and method for automatically generating technical product documentation by ingesting project artifacts from various platforms such as Git, Jira, Slack, and document repositories, extracting and classifying intents from each artifact using large language models, constructing a dynamic knowledge graph that maps relationships between requirements, design decisions, code components, and documentation, enabling reverse traceability between documentation and artifacts, generating human-readable documentation and diagrams based on the graph and updating the documentation incrementally as the underlying artifacts evolve. This pipeline enables living documentation that evolves in tandem with the software project

BRIEF DESCRIPTION OF DRAWINGS
A complete understanding of the present invention may be made by reference to the following detailed description which is to be taken in conjugation with the accompanying drawing. The accompanying drawing, which is incorporated into and constitutes a part of the specification, illustrates one or more embodiments of the present invention and, together with the detailed description, it serves to explain the principles and implementations of the invention.
FIG. 1a and 1b illustrates the system architecture and workflow of the present invention.

DETAILED DESCRIPTION OF THE INVENTION

Before the present invention is described, it is to be understood that this invention is not limited to methodologies described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention. Throughout this specification, the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the invention to achieve one or more of the desired objects or results. Various embodiments of the present invention are described below. It is, however, noted that the present invention is not limited to these embodiments, but rather the intention is that modifications that are apparent are also included.
The present invention relates to an automated product documentation system that generates technical documentation with minimum human intervention. The system is designed to create structured and intelligent documentation by reverse-engineering software development artifacts. It uses large language models (LLMs) along with project artifacts such as Git commits, Jira tickets, Slack messages, and internal documentation. The invention enables contextual understanding, traceability, and continuous updates through an efficient and scalable documentation pipeline.
The system consists of an ingestion layer , an LLM pipeline , a graph store , a traceability engine , a document renderer , and a change detector ; arranged functionally and sequentially as illustrated in Fig. 1a and 1b, wherein each component plays a critical role in enabling automated documentation generation.
According to the embodiment of the invention, the ingestion layer initiates the documentation generation process by collecting development artifacts from various platforms used in modern software development. The ingestion layer gathers data from version control systems such as Git. This includes commits, branches, pull requests, and diff summaries. It also collects project-related artifacts from project management tools like Jira. These include epics, stories, sub-tasks, and sprints. From communication tools such as Slack, it extracts relevant threads, technical discussions, and decision points, which provide additional context to development workflows. In addition, the ingestion layer pulls information from internal documentation repositories like Confluence and Google Docs. These may include architecture notes, API specifications, and technical design documents. The collected artifacts, although largely unstructured, form the input for the system. This data is processed in an automated [minimum human intervention] manner for generating structured documentation.
According to the embodiment of the invention, the LLM pipeline receives the unstructured data collected by the ingestion layer for further processing. The LLM pipeline uses large language models to perform intent-oriented artifact classification, which is essential for organizing artifacts based on their purpose in the development process. Each artifact is analyzed by the system to determine its intent and is then automatically [minimum human intervention] classified into one of the following categories: Requirement, Feature, Design Decision, Implementation Detail, or Bug Fix.
For example, a Jira ticket that reads "As a user, I want to reset my password" is identified as a Requirement. A related commit labelled "Add reset password UI" is classified under Implementation Detail. In addition to classification, each artifact is tagged with metadata, including the type of artifact, the timestamp of its creation, and its relevance to other artifacts. This structured classification stage prepares the data for the construction of the contextual knowledge graph in the next phase of the documentation pipeline.
According to the embodiment of the invention, the graph store constructs and maintains a contextual knowledge graph that forms the backbone of the documentation system. This graph is built using the artifacts and metadata processed by the LLM pipeline , and represents both the content and the connections between different development elements. The knowledge graph contains nodes that represent key entities such as commits, features, documents, and tickets. These nodes are connected by edges that define the relationships between the entities, including labels such as "implements", "discussed in", and "derived from". The graph store is dynamic, which means it can be updated over time as new artifacts are ingested or existing ones are modified. It supports temporal updates, allowing the system to reflect ongoing changes in the development process. It also supports traversal queries, which enable the system to navigate the relationships between artifacts and extract structured insights for downstream processes such as traceability and documentation generation.
For example, a node labelled “OAuth2 Feature” may be connected to a Jira story, a Git commit, and a Slack thread, showing how the feature was defined, discussed, and implemented across different platforms.
According to the embodiment of the invention, the traceability engine facilitates bi-directional traceability between generated documentation and development artifacts. This means that users can navigate from a specific section of the documentation to its related commits, tickets, and discussions, and vice versa. For instance, selecting “Reset Password Flow” in the documentation will provide links to the corresponding implementation details, design conversations, and requirements.
The traceability engine achieves this by leveraging the contextual knowledge graph constructed by the graph store . This graph comprises nodes representing entities such as commits, features, documents, and tickets, and edges denoting relationships like "implements", "discussed in", and "derived from". When a user queries a documentation section or artifact, the engine performs traversal queries on this graph to identify connected entities.
Subsequently, large language models (LLMs) are employed to interpret the retrieved data and generate human-readable documentation elements. This integration of graph queries with LLMs ensures that the traceability links are both accurate and presented in a comprehensible manner, enhancing the usability and reliability of the documentation system.
According to the embodiment of the invention, the document renderer is used to generate human-readable documentation and diagrams based on the knowledge graph. The document renderer produces executive summaries, component-level breakdowns, technical flows, and architecture diagrams using formats such as Mermaid or PlantUML. It uses the structure of the knowledge graph and the intent-classified artifacts to create natural language narratives that describe the relationships between features, commits, discussions, and design decisions. The generation process is automated [minimum human intervention], ensuring consistency, clarity, and scalability across documentation updates.
According to the embodiment of the invention, the change detector monitors the source platforms for new or modified artifacts. When a change is detected, it identifies and updates only the impacted nodes and relationships within the knowledge graph . Following this update, the document renderer triggers partial regeneration of the documentation, ensuring that only the relevant sections are refreshed. This process maintains the continuity of existing content while keeping the documentation current and aligned with the latest development activity.
In a preferred embodiment of the invention, the various components of the system are configured to perform the automated documentation process comprising the steps of:
● Ingesting project artifacts from Git, Jira, Slack, and internal document repositories using the ingestion layer ;
● Classifying the intent of each artifact using the LLM pipeline ;

● Constructing a knowledge graph using the graph store to map relationships among artifacts;

● Enabling traceability across artifacts and documentation using the traceability engine ;

● Generating human-readable documentation and architecture diagrams using the document renderer ; and

● Monitoring updates and triggering partial regeneration using the change detector .
According to an embodiment of the present invention, the document renderer ensures that the generated documentation is structured, human-readable, and contextually accurate, making it suitable for ongoing use across the development lifecycle.
The advantages of the product documentation system of the present invention are as follows:
● The present invention provides a scalable and intelligent documentation solution that reduces manual effort and minimizes inconsistencies by utilizing large language models and reverse engineering of software development artifacts.
● The system enables continuous and contextual documentation by classifying intent from unstructured artifacts such as Git commits, Jira tickets, Slack threads, and internal documentation, ensuring traceable and meaningful outputs.
● The system ensures organized data flow, bi-directional traceability, and structured representation through a dynamic knowledge graph, which maps relationships among features, commits, design decisions, and tickets.
● The invention supports living documentation that evolves with the software project, enabling partial regeneration based on updates detected in source platforms, and making it suitable for modern agile and Development and Operations (DevOps) environments where accuracy and ongoing updates are essential.
While considerable emphasis has been placed herein on the specific elements of the preferred embodiment, it will be appreciated that many alterations can be made and that many modifications can be made in preferred embodiment without departing from the principles of the invention. These and other changes in the preferred embodiments of the invention will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the invention and not as a limitation. , Claims:We Claim:
1. A system for automated product documentation generation, wherein the system comprises an ingestion layer , an LLM pipeline , a graph store , a traceability engine , a document renderer , and a change detector ; arranged functionally and sequentially to enable the structured generation of human-readable documentation from unstructured development artifacts;
characterized in that:
the ingestion layer collects development artifacts from version control systems, project management tools, communication platforms, and internal documentation repositories;
the LLM pipeline uses large language models to perform intent-oriented artifact classification, wherein each artifact is classified into one of the following categories: Requirement, Feature, Design Decision, Implementation Detail, or Bug Fix;
the graph store constructs and maintains a contextual knowledge graph representing nodes such as commits, features, documents, and tickets, and relationships including "implements", "discussed in", and "derived from";
the traceability engine enables bi-directional traceability between documentation sections and development artifacts using graph queries interpreted by large language models;
the document renderer generates executive summaries, component-level breakdowns, technical flows, and architecture diagrams using the knowledge graph and classified intents;
the change detector monitors source platforms for new or modified artifacts and updates only the impacted nodes and relationships within the knowledge graph , triggering partial regeneration of the documentation.

2. The system as claimed in claim 1, wherein the ingestion layer extracts commits, branches, pull requests, and diff summaries from Git; epics, stories, sub-tasks, and sprints from Jira; threads, technical discussions, and decision points from Slack; and architecture notes, API specifications, and technical design documents from Confluence and Google Docs.

3. The system as claimed in claim 1, wherein the LLM pipeline receives unstructured artifacts from the ingestion layer , analyses each artifact using large language models to determine its intent, classifies each artifact into one of the categories: Requirement, Feature, Design Decision, Implementation Detail, or Bug Fix, and tags each artifact with metadata including type, timestamp, and relevance to related artifacts, thereby preparing the data for construction of the contextual knowledge graph.

4. The system as claimed in claim 1, wherein the graph store supports temporal updates and traversal queries for representing evolving relationships and maintaining continuity in documentation.

5. The system as claimed in claim 1, wherein the traceability engine enables a user to navigate from a documentation section to associated commits, tickets, or discussions, and from an artifact to its corresponding documentation.

6. The system as claimed in claim 1, wherein the document renderer generates diagrams using Mermaid or PlantUML and produces documentation in markdown or HTML formats.

7. The system as claimed in claim 1, wherein the change detector preserves historical context while updating only the relevant sections of documentation based on changes detected in source artifacts.

8. A method for generating automated product documentation using the system as claimed in claim 1, the method comprising the steps of:
a. ingesting project artifacts from Git, Jira, Slack, and internal document repositories using the ingestion layer ;
b. classifying the intent of each artifact using the LLM pipeline ;
c. constructing a knowledge graph using the graph store to map relationships among artifacts;
d. enabling traceability across artifacts and documentation using the traceability engine ;
e. generating human-readable documentation and architecture diagrams using the document renderer ; and
f. monitoring updates and triggering partial regeneration using the change detector.
9. The system as claimed in claim 1, wherein the product documentation system reduces manual effort and minimizes inconsistencies; enables traceability between code, requirements, and design decisions; maintains living documentation that evolves with the software project; and leverages large language models for contextual understanding, making it suitable for agile and Development and Operations (DevOps) environments where accurate and continuous updates are essential.