DETAILED ACTION
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claim(s) 1-7, 10-17, and 20 is/are rejected under 35 U.S.C. 103 as being unpatentable over US 20250111167, hereinafter referred to as McIntyre et al., in view of US 20250209094, hereinafter referred to as Mandal et al.
Regarding claim 1, McIntyre et al. discloses a computing system comprising:
memory (McIntyre et al., para [0020].);
one or more hardware processors coupled to the memory (McIntyre et al., para [0020].); and
one or more computer readable storage media storing instructions (McIntyre et al., para [0127].) that, when loaded into the memory, cause the one or more hardware processors to perform operations comprising:
receiving a natural language query input from a user interface (“Alternatively, or in addition, a user may explicitly provide a context, such as performing a query for a particular topic or content, which may be performed by engaging with a search tool of a productivity application or by submitting the initial prompt intended for the LLM 240, McIntyre et al., para [0046]. And fig. 2(230)(502).);
extracting a target entity from the natural language query input (“In some embodiments, the user query interpreter 212 employs computing logic to infer an intent associated with an initial prompt. For example, the intent associated with the initial prompt is determined based on contextual information determined by the context extractor 214 of the user query interpreter 212. In some embodiments, context extractor 214 accesses user activity information and the initial prompt,” McIntyre et al., para [0045]. The extracted context is interpreted as a target entity.);
identifying a target application programming interface (API) corresponding to the target entity (“As described herein, context (or context logic) may be used to determine an intent and corresponding tasks associated with the initial prompt, to perform a semantic search for candidate LM skills, to submit a first communication prompting the LLM to describe a task, to submit a second communication prompting the LLM to select at least one target LM skill of the candidate LM skills, to execute an API call associated with the at least one target LM tool, to generate a user response to their initial prompt, and/or to be consumed by a computing application, among other operations,” McIntyre et al., para [0046].);
formulating an API query using the target API (McIntyre et al., para [0046]. The API call is interpreted as an API query.); and
executing the API query to generate a query output on the user interface (“As described herein, context (or context logic) may be used to determine an intent and corresponding tasks associated with the initial prompt, to perform a semantic search for candidate LM skills, to submit a first communication prompting the LLM to describe a task, to submit a second communication prompting the LLM to select at least one target LM skill of the candidate LM skills, to execute an API call associated with the at least one target LM tool, to generate a user response to their initial prompt, and/or to be consumed by a computing application, among other operations,” McIntyre et al., para [0046]. The response is a query output. And, McIntyre et al., fig. 5(520), shows that the response is provided to the user.),
wherein identifying the target API comprises:
generating a vector representation of the target entity (“Embodiments of the semantic search engine 224 perform a search to find related candidate LM skills within a semantic vector space to the task, for example, through the use of word embedding and vector representations of the task and query,” McIntyre et al., para [0054].);
searching an entity the semantic search engine 224 generates a query against data sources 260 for a candidate LM skills determined suitable for a corresponding task received from task generator 222,” McIntyre et al., para [0052].), wherein the searching returns one or more candidate APIs whose the semantic search engine 224 performs a search (for example, a semantic search) for the plurality of candidate LM skills against one or more databases of the data sources 260, such as those illustrated in FIG. 4,” McIntyre et al., para [0053].); and
prompting a generative artificial intelligence (AI) model to select the target API from the one or more candidate APIs (“In some embodiments, the inputs 601 additionally or alternatively include other inputs, such as the inputs to the LLM 240 described in FIGS. 2, 3, 4, and 5. In an illustrative example, in some embodiments, the predictions of the output 606 represent a description for a task or a selection of at least one target LM skill based on the tasks determined from the initial prompt and contextual information described herein. For instance, the predictions may be generative text, such as a generative answer to a question, machine translation text, or other generative text,” McIntyre et al., para [0097].).
McIntyre et al., though, does not specifically disclose searching an entity vector database containing vector representations of a plurality of APIs.
Mandal et al. is cited to disclose that the entity data base may comprise vectors (“The graph embeddings can represent various insights from multi-domain graph stores in a format (e.g., linearized vector format) easily usable by machine learning models integrated with the graphical representation layer. In various embodiments, a machine learning API system may apply one or more machine learning models based on the graph embeddings to initiate an action in response to an event,” Mandal et al., para [0031].). Mandal et al. benefits McIntyre et al. by supporting components of a server system in which inputs and/or components of the server system dynamically change (Mandal et al., para [0001]). Therefore, it would be obvious for one skilled in the art to combine the teachings of McIntyre et al. with those of Mandal et al. to overcome the server performance deficiencies of McIntyre et al.
As to claim 11, method claim 11 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 11 is similarly rejected under the same rationale as applied above with respect to system claim.
As to claim 20, CRM claim 20 and system claim 1 are related as system and CRM of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 20 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 2, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 1, wherein the operations further comprise creating the entity vector database (Mandal et al., para [0031], makes clear that the created graph embeddings may be stored as vectors.), wherein creating the entity vector database comprises:
extracting metadata from the plurality of APIs (“The term “feature dataset” refers to one or more features, data items or data elements associated with an API object (e.g., a service message object and/or a recommendation system object) that are collected and represented as part of a feature dataset. The feature dataset may refer to any information associated with an API object and/or a client device associated with an API object, such as, for example, unstructured service message data, metadata, a source identifier, a user identifier, a component identifier, a page or document identifier, one or more object types, feature extraction data, one or more text features…,” Mandal et al., para [0082]. Here, the extracted features may include metadata.);
generating an API graph based on the metadata extracted from the plurality of APIs (“In one or more embodiments, the graphical representation layer employs a database associated with graphical data structures to convert graph data associated with the graphical data structures into a graph embedding structure to be utilized for one or more machine learning models of a machine learning API system…In some embodiments, an API can be provided to interact with one or more machine learning models that utilize the respective graph embedding structures. For instance, in some embodiments, an API-driven user interface can be provided to enable interaction with the graphical representation layer. In one or more embodiments, the user interface provides a visualization related to actions managed by the graphical representation layer,” Mandal et al., para [0033].), wherein the API graph defines a plurality of entities representing the plurality of APIs and associations between the plurality of entities (“Graphical data structures may be used to characterize behaviors of users and or relationships across multiple domains of interactions and services. For example, a graphical data structure may be used to generate a graph feature set that includes one or more features associated with the graph data of the graphical data structure. A graphical data structure may store one or more portions of data objects and/or related data. For example, a graphical data structure may be used by an application framework to store one or more portions of data objects and/or related data,” Mandal et al., para [0061]. This excerpt shows that the graph may be based on extracted metadata (i.e., a type of feature).);
embedding the plurality of entities into respective vector representations of the plurality of APIs (“The graph embeddings can represent various insights from multi-domain graph stores in a format (e.g., linearized vector format) easily usable by machine learning models integrated with the graphical representation layer. In various embodiments, a machine learning API system may apply one or more machine learning models based on the graph embeddings to initiate an action in response to an event,” Mandal et al., para [0031].); and
storing the vector representations of the plurality of APIs in the entity vector database (“In one or more embodiments, the application framework system 105 includes a graph store 107 associated with one or more graphical data structures 109. The graphical data structures 109 may be associated with data sent to and/or received from the one or more components managed by the application framework 106. For example, the graph store 107 may store graph data for one or more component objects and component object dependencies that are represented by nodes and edges of the graphical data structure 109,” Mandal et al., para [0087]. And, “In some embodiments, the graph store 107 may include one or more graph databases containing graph data associated with one or more component objects and component object dependencies. In some embodiments, the graph data included in graph store 107 is augmented or transformed for compatibility with downstream operations,” Mandal et al., para [0088]. These two excerpts show that the graphical data is stored and that the storage may be updated. “The graph embeddings can represent various insights from multi-domain graph stores in a format (e.g., linearized vector format) easily usable by machine learning models integrated with the graphical representation layer,” Mandal et al., para [0031]. This excerpt makes clear that the created graph embeddings may be stored as vectors.).
As to claim 12, method claim 12 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 12 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 3, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 2, wherein embedding an entity representing an API comprises generating a first vector representation of the API based on metadata of the API (Mandal et al., para [0031].) and generating a second vector representation of the API based on one or more documents associated with the API (“The term “feature dataset” refers to one or more features, data items or data elements associated with an API object (e.g., a service message object and/or a recommendation system object) that are collected and represented as part of a feature dataset. The feature dataset may refer to any information associated with an API object and/or a client device associated with an API object, such as, for example, unstructured service message data, metadata, a source identifier, a user identifier, a component identifier, a page or document identifier, one or more object types, feature extraction data, one or more text features…,” Mandal et al., para [0082]. Thus, a vector representation may be based on a document identifier.).
As to claim 13, method claim 13 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 13 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 4, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 2, wherein the operations further comprise extracting a parameter value from the natural language query input (“In this example, the LLM 240 sends, to the orchestration loop, the target LM skill and corresponding API input parameters associated with the user input and the corresponding contextual information,” McIntyre et al., para [0082].), wherein formulating the API query comprises mapping the parameter value to a target input value, wherein the mapping comprises:
generating a vector representation of the parameter value (“At least one target LM skill of the plurality of candidate LM skills is selected based on a level of relatedness determined based on a proximity in semantic vector space between the respective output and the input,” McIntyre et al., para [0082].);
searching a value
prompting the generative AI model to select the target input value from the one or more candidate input values (“In some embodiments, after the orchestration loop is run for each task, a response 520 from the LLM 240 is directly communicated from the LLM 240 to the user device. Embodiments of the orchestration loop comprise computations for prompting the LLM 240 to select the at least one target LM skill based on the at least one task associated with the input,” McIntyre et al., para [0083].).
Mandal et al., para [0087], makes clear that the database may be a value
As to claim 14, method claim 14 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 14 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 5, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 4, wherein the operations further comprise creating the value vector database, wherein creating the value vector database comprises:
identifying the plurality of input values that can be provided as input for parameters of the plurality of APIs (“FIG. 8 depicts a flow diagram of a method for generating an API call associated with at least one target LM skill and comprising an API parameter input into an API of the at least one target LM skill based on a first task and a second task associated with an initial prompt, in accordance with an embodiment of the present disclosure,” McIntyre et al., para [0016]. And, “In this example, the intermediate LM skill layer 210 receives the target LM skill and corresponding API parameter inputs for generating an API call to the target LM skill. For example, the API parameter inputs are generated based on the task, the initial prompt, the user request, the contextual information received from context database 312, and/or the intent, McIntyre et al., para [0070].);
embedding the plurality of input values into respective vector representations of the plurality of input values (“In one embodiment, documents, such as articles associated with LM skills, web pages associated with LM skills, or queries associated with LM skills, are also transformed into vectors by aggregating or averaging the word embeddings of the words within them, generating a vector representation of the document's semantic meaning,” McIntyre et al., para [0054].); and
storing the vector representations of the plurality of input values into the value vector database (“The graph embeddings can represent various insights from multi-domain graph stores in a format (e.g., linearized vector format) easily usable by machine learning models integrated with the graphical representation layer. In various embodiments, a machine learning API system may apply one or more machine learning models based on the graph embeddings to initiate an action in response to an event,” Mandal et al., para [0031].).
As to claim 15, method claim 15 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 15 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 6, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 5, wherein embedding an input value comprises generating a first vector representation of the input value based on a unique identifier of the input value (“In some embodiments, an event may be associated with metadata, a unique identifier, one or more attributes, one or more tags, one or more classifications, one or more source identifiers, one or more object types, software data, and/or other context data,” Mandal et al., para [0051].) and generating a second vector representation of the input value based on a text description of the input value (“The term “visualization” refers to visual representation of data to facilitate human interpretation of the data. In some embodiments, visualization of data includes graphic representation and/or textual representation of data,” Mandal et al., para [0058].).
As to claim 16, method claim 16 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 16 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 7, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 4, wherein extracting the target entity and the parameter value comprises prompting the generative AI model with the natural language query input (“In this example, the LLM 240 sends, to the orchestration loop, the target LM skill and corresponding API input parameters associated with the user input and the corresponding contextual information,” McIntyre et al., para [0082]. And, “In some embodiments, after the orchestration loop is run for each task, a response 520 from the LLM 240 is directly communicated from the LLM 240 to the user device. Embodiments of the orchestration loop comprise computations for prompting the LLM 240 to select the at least one target LM skill based on the at least one task associated with the input,” McIntyre et al., para [0083].).
As to claim 17, method claim 17 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 17 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 10, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 1, wherein the operations further comprise:
validating the API query prior to executing the API query (“In some embodiments, the external component may communicate with an application calling the external component, and vice versa, through one or more APIs. For example, the application calling the external component may subscribe to an API of the external component that is configured to transmit data. In some embodiments, the external component receives tokens or other authentication credentials that are used to facilitate secure communication between the external component and an application calling the external component in view of the applications network security features or protocols (e.g., network firewall protocols),” Maldal et al., para [0055].); and
formatting the query output, wherein the formatting comprises prompting the generative AI model (“Non-limiting examples of components include an open source API definition format, an internal developer tool, web based HTTP components, databased components, and asynchronous message queues which facilitate component-to-component communications,” Mandal et al., para [0045].).
Claim(s) 8-9 and 18 is/are rejected under 35 U.S.C. 103 as being unpatentable over US 20250111167, hereinafter referred to as McIntyre et al., in view of US 20250209094, hereinafter referred to as Mandal et al., and further in view of US 20230297927, hereinafter referred to as Jagadeesan et al.
Regarding claim 8, McIntyre et al., as modified by Mandal et al., discloses the computing system of claim 4, but not wherein formulating the API query comprises prompting the generative AI model to generate an API syntax based on the target API and the target input value.
Jagadessan et al. is cited to disclose wherein formulating the API query comprises prompting the generative AI model to generate an API syntax based on the target API and the target input value (“More specifically, in various embodiments, the skill-tag standardizer described herein obtains the skills-relevant object metadata through a set of APIs, e.g., by taking either text or other object identifiers or object properties in the property graph as the input,” Jagadeesan et al., para [0053].). Jagadeesan et al. benefits McIntyre et al. by providing a centralized skills management server for standardized skill tagging (Jagadeesan et al., para [0001]). Therefore, it would be obvious for one skilled in the art to combine the teachings of McIntyre et al. with those of Jagadeesan et al. to overcome the server performance deficiencies of McIntyre et al.
As to claim 18, method claim 18 and system claim 1 are related as system and method of using same, with each claimed element’s function corresponding to the system step. Accordingly claim 18 is similarly rejected under the same rationale as applied above with respect to system claim.
Regarding claim 9, McIntyre et al., as modified by Mandal et al. and Jagadeesan et al., discloses the computing system of claim 8, wherein formulating the API query further comprises adding tenant configurations (“For this solution, skills management providers offer APIs that take tenant skills lists and/or tenant-specific resources as input and then build the relevant tenant-level skills ontology on top of the provider's OOB skills ontology,” Jagadeesan et al., para [0038].) and authentication data to the API syntax (“More specifically, in various embodiments, the skill-tag standardizer described herein obtains the skills-relevant object metadata through a set of APIs, e.g., by taking either text or other object identifiers or object properties in the property graph as the input,” Jagadeesan et al., para [0053].).
Claim(s) 19 is/are rejected under 35 U.S.C. 103 as being unpatentable over US 20250111167, hereinafter referred to as McIntyre et al., in view of US 20250209094, hereinafter referred to as Mandal et al., and further in view of https://www.akkio.com/post/chatgpt-advanced-data-analysis, hereinafter referred to as ChatGPT Data Analysis.
Regarding claim 19, McIntyre et al., as modified by Mandal et al., discloses the computer-implemented method of claim 11, but not further comprising formatting the query output, wherein the formatting comprises prompting the generative AI model to transform the query output from a JSON format to a table format. ChatGPT Data Analysis is cited to disclose formatting the query output, wherein the formatting comprises prompting the generative AI model to transform the query output from a JSON format to a table format (https://www.akkio.com/post/chatgpt-advanced-data-analysis . This site allows a user to provide a prompt with a JSON format and receive a table output. Also, according to the WaybackMachine, the site has been active since at least December 27, 2023.). ChatGPT Data Analysis benefits McIntyre et al. by allowing the using to request data to be displayed in a more readable format. Therefore, it would be obvious for one skilled in the art to combine the teachings of McIntyre et al. with those of ChatGPT Data Analysis benefits McIntyre et al. to improve the user interaction experience of McIntyre et al.
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure. See attached PTO-892. In particular, the examiner notes Singh and Khosla, both of which describe APIs in conjunction with Generative AI prompts.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to ANNE L THOMAS-HOMESCU whose telephone number is (571)272-0899. The examiner can normally be reached Mon-Fri 8-6.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Bhavesh M Mehta can be reached on 5712727453. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/ANNE L THOMAS-HOMESCU/Primary Examiner, Art Unit 2656