DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Response to Amendment
In response to the office action from 1/2/2026, the applicant has submitted an amendment, filed 4/1/2026, amending claims 6, 7, 17, 18, and 20, while arguing to traverse the prior art rejections. Applicant’s arguments have been fully considered and the previous grounds of rejections are maintained for the reasons explained in the response to arguments.
Response to Arguments
Following a broad overview of the latest amendments (page 7 ¶’s 1-2) and a broad overview of the last office action (remainder of page 7 and page 8 ¶ 1), on page 9 the second ¶, it is asserted: “Kotte is to improve response accuracy, not to manage cache capacity” “The optimization goal is unrelated to the cache management goal of selecting which data to remove”.
Respectfully what is characterized in this quotation is Not strictly what Kotte is concerned. Furthermore “cache” is merely one storage medium example. To help efficient or optimized use of any other storage media does provide alternative solutions for cache as well. And since the primary reference Byron et al. is already concerned about “cache” management, therefore their combination does read on a management as taught by Kotte and specialized to “cache”.
Next, the quotation above is incorrect characteristic of Kotte, because according to Kotte page 19 column 2 ¶’s 2-3: “to process the stored digital documents” “generate, from the set of question-answer pairs, a subset of question-answer pairs by removing redundant question-answer pairs using a Levenshtein distance”. To “remove” “redundant” “pairs” to manage “stored digital documents” certainly amounts at least in part to a memory management activity which invalidates the claim above.
Page 8, the 4th ¶ last 2 sentences recited: “Kotte does not teach comparing cached pairs to identify which pair has the minimal distance to any other pir in a cache as in claim 1. A combination of Byron and kotte therefore do not teach or suggest this feature of claim 1”.
As an initial matter, this statemet does not specifically correspond to any claim limitations; secondly to determine a “Levenshtein distance” between “two questions answer pairs” (Kotte ¶ 0094 S4-4) amounts to quantifying a comparison between them.
Page 8, the last ¶ asserts: “to remove “redundant” question-anser pairs form Byron’s cache appears only with knowledge of Applicant’s invention. This improver hindsight reconstruction reads Kotte’s redundancy-removal teaching back into Byron without identifying any teaching or suggestion in the references that such a modification would be desirable for cache management”. On page 9 the 2nd ¶, last sentence it is further noted: “Additionally, the advantages of caches are already realized in Byron, with Kotte not providing anything further”.
As regards to “improper hindsight” respectfully see: Kotte page 19 column 2 ¶’s 2-3: “to process the stored digital documents” “generate, from the set of question-answer pairs, a subset of question-answer pairs by removing redundant question-answer pairs using a Levenshtein distance”. This expressly teaches addressing redundancy for “stor[age]” (memory) management. As regards to motivation to combining references Kotte ¶ 0056 “significantly reduc[ing] computational costs” was used. And finally this quoted teaching should definitely teach “further” “advantages” for the said “stora[ge]” management by “removing” “redundant” “pairs”.
On page 9 the 3rd ¶ similar conclusion is asserted for the other independent claims 11 and 20 and “request[ed] reconsideration and withdrawal of the 103 rejection”.
Respectfully for the reasons above this is not possible at this point.
Page 9 ¶ 4 asserted: “Applicant appreciatively acknowledges the Examiner’s indication during the Interview” “that claim 3 is allowable”.
Respectfully there appears to be a misunderstanding. The claim 3 as presented in the interview was an amended claim 3. The current claim 3 in original form was and is rejected. Furthermore no commitment for allowance was made for that amendment. It was simply stated that the amendment required further search and examination.
As regards to claim 4 following some arguments made on page 9, on page 10 the first ¶, it is concluded: “Comparing the latencies between physical storage devices is not related to and does not suggest the latency associated with re-generating the particular query-response pairs using the language model”.
Respectfully according to Byron et al. ¶ 0014 S3: “ provide mechanisms to cache natural language questions and their corresponding answers to reduce the computational time/resources required to provide a response to a submitted question”. To “reduce” “time” to find “response” (answer) to a “question” (question) amounts to determining a period or duration or latency to generate and/or regenerate a question answer pair, and the means to generate the “response” corresponds to a language model.
As regards to claim 6 on page 10 the last two ¶’s concludes in: “to retrieve from a repository is not related to and does not suggest a utility for determining what to remove from a cache. The claimed utility score requires a fundamentally different comparison operation that Kotte’s context scores”.
Respectfully Kotte ¶ 0130 S before last teach: “removing” “redundant question-answer pairs” is based on “Levenshtein distance” which is quantified by the “context score” (claim’s utility score); i.e., the said “score” is used to assess “similarity” which is used . Furthermore according to ¶ 0094: “If the answers are too semantically similar (e.g., meet a threshold redundancy), the contextual query answering system 106 removes one of the question-answer pairs”, therefore the said “score” which is a gauge for “similarity” (¶ 0070 S3: “the context scores 414 representing a similarity”) determination is basis for the said removal for Kotte page 19 column 2 ¶’s 2-3: “to process the stored digital documents” (memory management).
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-3, 5-6, 8, 10-14, 16-17, 19-20 is/are rejected under 35 U.S.C. 103 as being unpatentable over Byron et al. (US 2014/0377735), and further in view of Kotte et al. (US 2025/0252265).
Regarding claim 1, Byron et al. do teach A method (Title, Abstract)
comprising:
storing, by a device and in a cache, a plurality of query-response pairs of queries
issued to a language model and their corresponding answers from the language model (¶ 0016 S1-2: “With the mechanisms of the illustrative embodiments, a cache store is provided for storing” (storing in a “cache”) “information about previously processed questions and the candidate answers” (a plurality of query-response pairs) “returned by a QA system as part of the processing of these questions. Moreover, logic is provided to determine a similarity between a current question being processed and one or more of the cached previously processed questions”; ¶ 0061 S2-3: “As discussed above, during the question and topic analysis stage 320, the input question 310” (an input query) “is parsed using natural language processing (NLP)” (is submitted to a language model) “techniques to extract major features from the input question, classify the major features according to types, etc. The extracted features may also be provided to the question/answer caching logic 390. The question/answer caching logic 390 may compare the extracted features to those stored for previously processed questions in the QA cache 395” (in order to obtain corresponding answers));
determining, by the device, that the cache should be pruned based on a size of the cache exceeding a threshold size (¶ 0061 S before last: “The creation of the new entry may require” (determining) “the eviction” (if pruning) “of an existing entry if the QA cache” (of the cache) “395 is presently full” (based on its capacity or a threshold size is required));
selecting, by the device, a particular query-response pair from amongst the plurality of query-response pairs or pairs from the “question/answer cashing logic” (amongst the plurality of query-response pairs)) “least used (if counters are associated with cache entries), or the like”)
and
pruning, by the device, the particular query-response pair from the cache (¶ 0061 last S: “Any cache eviction” (pruning) “policy may be implemented by the question/answer caching logic, including least recently used (LRU)” (the particular specific query-response pair) “least used (if counters are associated with cache entries), or the like”).
Byron et al. do not specifically disclose:
The selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs.
Kotte et al. do teach:
A pruning selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs (¶ 0130 S before last: “the series of acts 110 includes generating” (selecting) “from the set of question answer pairs” “a subset of question-answer pairs by removing” (by pruning) “redundant question-answer pairs” (e.g. a particular query response pair) “using a Levenshtein distance” (abiding by a score which depends on “semantic similarit[]” (semantic distance) when minimized from another question answer pair: i.e., ¶ 0094 S4-5: “If the Levenshtein distance is below a threshold amount for two question-answer pairs” “the contextual query answering system 106 computes the semantic similarity between the answers for the two question-answer pairs. If the answers are too semantically similar” (i.e., if “semantic similarity” (semantic distance) is below a minimal) “the contextual query answering system” “removes” (it prunes) “one of the question answer pairs” (e.g., the particular query response pair) “from the relevant question answer pairs” “provided to the response generator model”).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “Levenshtein distance” for “similarity” calculation between “two question-answer pairs” of Kotte et al. into the “cache eviction policy” of Byron et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further enable Byron et al. to readily determine “redundant” “question-answer pairs” for their efficient “eviction” from its “cache” and “significantly reduced computational costs and resources” as disclosed in Kotte et al. ¶ 0056 last S.
Regarding claim 2, Byron et al. do teach the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs further based on a frequency of access of each of the plurality of query-response pairs (¶ 0061 last S: “Any cache eviction” (selecting for pruning) “policy may be implemented by the question/answer caching logic, including least recently used (LRU)” (based on frequency of access of each question answer pair)) “least used (if counters are associated with cache entries), or the like”
Regarding claim 3, Byron et al. do teach the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs based further on a cost associated with the particular query-response pair (¶ 0035 last S: “The illustrative embodiments” (the “eviction” (pruning procedure including its selection)) “leverage the work already done by the QA system to reduce the computation time and resource cost” (is further based on cost) “for subsequent processing of questions that are similar to questions already processed by the QA system”).
Regarding claim 5, Byron et al. do teach the method as in claim 1, wherein the device prunes the particular query-response pair from the cache to free up storage space for storage of a new query-response pair (¶ 0061 S before last: “The creation of the new entry may require” “the eviction” (the pruning) “of an existing entry if the QA cache” (of the cache) “395 is presently full” (is mandated by freeing up storage as dictated by the cache size for new “QA” (query response pairs))).
Regarding claim 6, Byron et al. do not specifically disclose the method as in claim 1, wherein selecting the particular query-response pair from amongst the plurality of query-response pairs further comprises:
computing a utility score for the particular query-response pair that weights its minimal semantic distance to the another query-response pair in the plurality of query-
response pairs.
Kotte et al. do teach:
computing a utility score for the particular query-response pair that weights its minimal semantic distance to the another query-response pair in the plurality of query-response pairs (¶ 0070 S2: “For example, the contextual query answering system 106 generates the context scores” (computing a utility score) “414 representing a similarity” “e.g., a cosine similarity or an embedding space distance” (which weights the minimal semantic distance used in the “semantic similarity” (the semantic distance) calculation used for the query response pair selection for the “removing” (pruning ¶ 0130)) “between the query” (between query response pairs) “embedding 406 and the data segment embeddings 412” (i.e., the smaller the “distance”, the larger is the “cosine” (i.e., resulting in higher score), so minimal semantic distance weights in higher utility score)).
For obviousness to combine Byron et al. and Kotte et al. see claim 1.
Regarding claim 8, Byron et al. do teach the method as in claim 1, further comprising:
searching the cache to match a new query for input to the language model to an existing query in the cache (Abstract S2+: “An input question” (a new query) “to be answered from a source is received and processed to one or more extract features” (submitted to the language model) “of the input question. The extracted one or more features are compared” (is searched) “to cached features stored in one or more entries of a question and answer (QA) cache” (in the catch for an existing “question” (query));
, and
providing a response associated with the existing query as a response to the new query, in lieu of inputting the new query to the language model (Abstract S4+: “A determination is made as to whether there is a matching” (if a matching is found) “entry in the one or more entries of the QA cache based on results of the comparing and, if so, candidate answer information is retrieved from the matching entry. The retrieved candidate answer” (a response associated with the new query) “information is returned” (is provided) “to the source of the input question as candidate answer information for answering the input question”).
Regarding claim 10, Byron et al. do not specifically disclose the method as in claim 1, wherein the language model is a large language model (LLM).
Kotte et al. do teach the method as in claim 1, wherein the language model is a large language model (LLM) (¶ 0017: “This disclosure describes one or more embodiments that utilize a contextual query answering system to train and implement machine learning models” “e.g., large language models” (using large language model to the “query answering” (query response)) “to provide accurate domain-specific contextual answers for software applications”).
For obviousness to combine Byron et al. and Kotte et al. see claim 1.
Regarding claim 11, Byron et al. do not specifically disclose the method as in claim 1, wherein the device selects the particular query-response pair by:
computing a vector corresponding to the particular query-response pair and a vector corresponding to a second query-response pair in the cache; and
determining a semantic similarity between the particular query-response pair and the second query-response pair by comparing their corresponding vectors.
Kotte et al. do teach:
the device selects the particular query-response pair by:
computing a vector corresponding to the particular query-response pair and a vector corresponding to a second query-response pair in the cache (Abstract S3: “The disclosed systems utilize a context retrieval model to generate query embeddings from the contextual query”; ¶ 0044 S3: “The query embeddings 210 and the data segment embeddings 212 include token-specific embeddings” “e.g., latent vectors” (computing vectors corresponding to each one of the “questions” (queries), e.g., in the “two question-answer pairs” for which the “Levenshtein distance” used in determining “semantic similarity” is computed (¶ 0094)); and
determining a semantic similarity between the particular query-response pair and the second query-response pair by comparing their corresponding vectors (¶ 0045 last 2S: “To illustrate, the contextual query answering” (the “two questions answer pairs” in ¶ 0094 lines 14-16) “system 106 utilizes the vector embedding” (are converted to vector representations for making comparisons) “repository 214 to compare embeddings in the embedding space and determine to data segment embeddings 212 within a threshold distance” (to determine the “Levenshtein distance” and resulting “semantic similarity” (semantic similarity (¶ 0094 lines 14-16))) “of the query embeddings 210. By utilizing the vector embedding repository 204, the contextual query answering system 106 to quickly retrieves the vector representation of the data segment embeddings 212 for the prompt 218”).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “query” “vector embedding” methods used in all “question-answer” calculations of Kotte et al. into the “question/answer caching logic 390” of Byron et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further enable Byron et al. “to quickly” “retrieve the relevant answers” for each “contextual query” as disclosed in Kotte et al. ¶ 0045-46 last sentences.
Regarding claim 12, Byron et al. do teach an apparatus (Title, Abstract)
comprising:
one or more network interfaces; a processor coupled to the one or more network interfaces and configured to execute one or more processes; and a memory configured to store a process that is executable by the processor (¶ 0036 S2: “The QA system 100 may be implemented on one or more computing devices 104 (comprising one or more processors and one or more memories, and potentially any other computing device elements generally known in the art including buses, storage devices, communication interfaces, and the like) connected to the computer network 102. The network 102 may include multiple computing devices 104 in communication with each other and with other devices or components via one or more wired and/or wireless data communication links”),
the process when executed configured to:
store, in a cache, a plurality of query-response pairs of queries
issued to a language model and their corresponding answers from the language model (¶ 0016 S1-2: “With the mechanisms of the illustrative embodiments, a cache store is provided for storing” (storing in a “cache”) “information about previously processed questions and the candidate answers” (a plurality of query-response pairs) “returned by a QA system as part of the processing of these questions. Moreover, logic is provided to determine a similarity between a current question being processed and one or more of the cached previously processed questions”; ¶ 0061 S2-3: “As discussed above, during the question and topic analysis stage 320, the input question 310” (an input query) “is parsed using natural language processing (NLP)” (is submitted to a language model) “techniques to extract major features from the input question, classify the major features according to types, etc. The extracted features may also be provided to the question/answer caching logic 390. The question/answer caching logic 390 may compare the extracted features to those stored for previously processed questions in the QA cache 395” (in order to obtain corresponding answers));
determine that the cache should be pruned based on a size of the cache exceeding a threshold size (¶ 0061 S before last: “The creation of the new entry may require” (determining) “the eviction” (if pruning) “of an existing entry if the QA cache” (of the cache) “395 is presently full” (based on its capacity or a threshold size is required));
select a particular query-response pair from amongst the plurality of query-response pairs including least recently used (LRU)” (e.g., a particular query-response pair or pairs from the “question/answer cashing logic” (amongst the plurality of query-response pairs)) “least used (if counters are associated with cache entries), or the like”)
and
prune the particular query-response pair from the cache (¶ 0061 last S: “Any cache eviction” (pruning) “policy may be implemented by the question/answer caching logic, including least recently used (LRU)” (the particular specific query-response pair) “least used (if counters are associated with cache entries), or the like”).
Byron et al. do not specifically disclose:
The selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs.
Kotte et al. do teach:
A pruning selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs (¶ 0130 S before last: “the series of acts 110 includes generating” (selecting) “from the set of question answer pairs” “a subset of question-answer pairs by removing” (by pruning) “redundant question-answer pairs” (e.g. a particular query response pair) “using a Levenshtein distance” (abiding by a score which depends on “semantic similarit[]” (semantic distance) when minimized from another question answer pair: i.e., ¶ 0094 S4-5: “If the Levenshtein distance is below a threshold amount for two question-answer pairs” “the contextual query answering system 106 computes the semantic similarity between the answers for the two question-answer pairs. If the answers are too semantically similar” (i.e., if “semantic similarity” (semantic distance) is below a minimal) “the contextual query answering system” “removes” (it prunes) “one of the question answer pairs” (e.g., the particular query response pair) “from the relevant question answer pairs” “provided to the response generator model”).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “Levenshtein distance” for “similarity” calculation between “two question-answer pairs” of Kotte et al. into the “cache eviction policy” of Byron et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further enable Byron et al. to readily determine “redundant” “question-answer pairs” for their efficient “eviction” from its “cache” and “significantly reduced computational costs and resources” as disclosed in Kotte et al. ¶ 0056 last S.
Regarding claim 13, Byron et al. do teach the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs further based on a frequency of access of each of the plurality of query-response pairs (¶ 0061 last S: “Any cache eviction” (selecting for pruning) “policy may be implemented by the question/answer caching logic, including least recently used (LRU)” (based on frequency of access of each question answer pair)) “least used (if counters are associated with cache entries), or the like”
Regarding claim 14, Byron et al. do teach the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs based further on a cost associated with the particular query-response pair (¶ 0035 last S: “The illustrative embodiments” (the “eviction” (pruning procedure including its selection)) “leverage the work already done by the QA system to reduce the computation time and resource cost” (is further based on cost) “for subsequent processing of questions that are similar to questions already processed by the QA system”).
Regarding claim 16, Byron et al. do teach the apparatus as in claim 12, wherein the device prunes the particular query-response pair from the cache to free up storage space for storage of a new query-response pair (¶ 0061 S before last: “The creation of the new entry may require” “the eviction” (the pruning) “of an existing entry if the QA cache” (of the cache) “395 is presently full” (is mandated by freeing up storage as dictated by the cache size for new “QA” (query response pairs))).
Regarding claim 17, Byron et al. do not specifically disclose the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs further by:
computing a utility score for the particular query-response pair that weights its minimal semantic distance to another query-response pair in the plurality of query-
response pairs.
Kotte et al. do teach:
computing a utility score for the particular query-response pair that weights its minimal semantic distance to another query-response pair in the plurality of query-response pairs (¶ 0070 S2: “For example, the contextual query answering system 106 generates the context scores” (computing a utility score) “414 representing a similarity” “e.g., a cosine similarity or an embedding space distance” (which weights the minimal semantic distance used in the “semantic similarity” (the semantic distance) calculation used for the query response pair selection for the “removing” (pruning ¶ 0130)) “between the query” (between query response pairs) “embedding 406 and the data segment embeddings 412” (i.e., the smaller the “distance”, the larger is the “cosine” (i.e., resulting in higher score), so minimal semantic distance weights in higher utility score)).
For obviousness to combine Byron et al. and Kotte et al. see claim 12.
Regarding claim 19, Byron et al. do teach the apparatus as in claim 12, wherein the process when executed is further configured to:
search the cache to match a new query for input to the language model to an existing query in the cache (Abstract S2+: “An input question” (a new query) “to be answered from a source is received and processed to one or more extract features” (submitted to the language model) “of the input question. The extracted one or more features are compared” (is searched) “to cached features stored in one or more entries of a question and answer (QA) cache” (in the catch for an existing “question” (query));
, and
provide a response associated with the existing query as a response to the new query, in lieu of inputting the new query to the language model (Abstract S4+: “A determination is made as to whether there is a matching” (if a matching is found) “entry in the one or more entries of the QA cache based on results of the comparing and, if so, candidate answer information is retrieved from the matching entry. The retrieved candidate answer” (a response associated with the new query) “information is returned” (is provided) “to the source of the input question as candidate answer information for answering the input question”).
Regarding claim 20, Byron et al. do teach a tangible, non-transitory, computer-readable medium storing program instructions (¶ 0006: “In other illustrative embodiments, a computer program product comprising a computer useable or readable medium having a computer readable program is provided. The computer readable program, when executed on a computing device, causes the computing device to perform various ones of, and combinations of, the operations outlined above with regard to the method illustrative embodiment”)
That cause a device to execute a process
comprising:
storing, by the device and in a cache, a plurality of query-response pairs of queries
issued to a language model and their corresponding answers from the language model (¶ 0016 S1-2: “With the mechanisms of the illustrative embodiments, a cache store is provided for storing” (storing in a “cache”) “information about previously processed questions and the candidate answers” (a plurality of query-response pairs) “returned by a QA system as part of the processing of these questions. Moreover, logic is provided to determine a similarity between a current question being processed and one or more of the cached previously processed questions”; ¶ 0061 S2-3: “As discussed above, during the question and topic analysis stage 320, the input question 310” (an input query) “is parsed using natural language processing (NLP)” (is submitted to a language model) “techniques to extract major features from the input question, classify the major features according to types, etc. The extracted features may also be provided to the question/answer caching logic 390. The question/answer caching logic 390 may compare the extracted features to those stored for previously processed questions in the QA cache 395” (in order to obtain corresponding answers));
determining, by the device, that the cache should be pruned based on a size of the cache exceeding a threshold size (¶ 0061 S before last: “The creation of the new entry may require” (determining) “the eviction” (if pruning) “of an existing entry if the QA cache” (of the cache) “395 is presently full” (based on its capacity or a threshold size is required));
selecting, by the device, a particular query-response pair from amongst the plurality of query-response pairs
and
pruning, by the device, the particular query-response pair from the cache (¶ 0061 last S: “Any cache eviction” (pruning) “policy may be implemented by the question/answer caching logic, including least recently used (LRU)” (the particular specific query-response pair) “least used (if counters are associated with cache entries), or the like”).
Byron et al. do not specifically disclose:
The selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs.
Kotte et al. do teach:
A pruning selecting to be based on that pair having a minimal semantic distance to another query-response pair in the plurality of query-response pairs (¶ 0130 S before last: “the series of acts 110 includes generating” (selecting) “from the set of question answer pairs” “a subset of question-answer pairs by removing” (by pruning) “redundant question-answer pairs” (e.g. a particular query response pair) “using a Levenshtein distance” (abiding by a score which depends on “semantic similarit[]” (semantic distance) when minimized from another question answer pair: i.e., ¶ 0094 S4-5: “If the Levenshtein distance is below a threshold amount for two question-answer pairs” “the contextual query answering system 106 computes the semantic similarity between the answers for the two question-answer pairs. If the answers are too semantically similar” (i.e., if “semantic similarity” (semantic distance) is below a minimal) “the contextual query answering system” “removes” (it prunes) “one of the question answer pairs” (e.g., the particular query response pair) “from the relevant question answer pairs” “provided to the response generator model”).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “Levenshtein distance” for “similarity” calculation between “two question-answer pairs” of Kotte et al. into the “cache eviction policy” of Byron et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further enable Byron et al. to readily determine “redundant” “question-answer pairs” for their efficient “eviction” from its “cache” and “significantly reduced computational costs and resources” as disclosed in Kotte et al. ¶ 0056 last S.
Claim(s) 4, 7, 15, 18 is/are rejected under 35 U.S.C. 103 as being unpatentable over Byron et al. in view of Kotte et al., and further in view of Muniswamy Reddy et al. (US Patent 11,561,930).
Regarding claim 4, Byron et al. in view of Kotte et al. do not specifically disclose the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs based further on a latency associated with re-generating the particular query-response pair using the language model.
Muniswamy Reddy et al. do teach the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs based further on a latency associated with re-generating the particular query-response pair using the language model (Col. 24 lines 23-31: “the replica” (e.g., a response to a “query”) “is removed” (is selected for pruning) “from the cache” (from cache) “in response to determining, at the first query accelerator node, that the data item meets an eviction criterion, wherein the eviction criterion comprises one or more of: (a) a criterion based on a time at which the data item was accessed” (based on a “latency” i.e., if it took too much time to be “accessed” (Col. 13 lines 13-17)) (b) a time-to-live criterion, (c) a size criterion, (d) a locality criterion or (e) a criterion based on a property of a client-side component of an acceleration service” (also another latency type criterion); i.e., Col. 13 lines 13-17: “The volatile memory portion of the cache” “has” “an average access latency” (based on latency) “e.g., a read response time for a data item of a selected size” (a time to respond or access is determined)).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “cache” management criteria of Muniswamy Reddy et al. into the “QUESTION/ANSWER CACHING LOGIC” of Byron et al. in Byron et al. in view of Kotte et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further aid them in achieving “an acceleration service” as disclosed in Muniswamy Reddy et al. Col. 24 line 30-31.
Regarding claim 7, Byron et al. in view of Kotte et al. do not specifically disclose the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs based further on a size of the particular query-response pair in the cache.
Muniswamy Reddy et al. do teach the method as in claim 1, wherein the device selects the particular query-response pair from amongst the plurality of query-response pairs based further on a size of the particular query-response pair in the cache (Col. 24 lines 62-67: “the replica” (e.g., a response to a “query”) “is removed” (is selected for pruning) “from the cache” (from cache) “in response to determining, at the first query accelerator node, that the data item meets an eviction criterion, wherein the eviction criterion comprises one or more of: (a) a criterion based on a time at which the data item was accessed” (b) a time-to-live criterion, (c) a size criterion” (based on a size associated with the “query” (query) “data item” (response))).
For obviousness to combine Byron et al. in view of Kotte et al. and Muniswamy Reddy et al. see claim 4.
Regarding claim 15, Byron et al. in view of Kotte et al. do not specifically disclose the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs based further on a latency associated with re-generating the particular query-response pair using the language model.
Muniswamy Reddy et al. do teach the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs based further on a latency associated with re-generating the particular query-response pair using the language model (Col. 24 lines 23-31: “the replica” (e.g., a response to a “query”) “is removed” (is selected for pruning) “from the cache” (from cache) “in response to determining, at the first query accelerator node, that the data item meets an eviction criterion, wherein the eviction criterion comprises one or more of: (a) a criterion based on a time at which the data item was accessed” (based on a “latency” i.e., if it took too much time to be “accessed” (Col. 13 lines 13-17)) (b) a time-to-live criterion, (c) a size criterion, (d) a locality criterion or (e) a criterion based on a property of a client-side component of an acceleration service” (also another latency type criterion); i.e., Col. 13 lines 13-17: “The volatile memory portion of the cache” “has” “an average access latency” (based on latency) “e.g., a read response time for a data item of a selected size” (a time to respond or access is determined)).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “cache” management criteria of Muniswamy Reddy et al. into the “QUESTION/ANSWER CACHING LOGIC” of Byron et al. in Byron et al. in view of Kotte et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further aid them in achieving “an acceleration service” as disclosed in Muniswamy Reddy et al. Col. 24 line 30-31.
Regarding claim 18, Byron et al. in view of Kotte et al. do not specifically disclose the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs based further on a size of the particular query-response pair in the cache.
Muniswamy Reddy et al. do teach the apparatus as in claim 12, wherein the apparatus selects the particular query-response pair from amongst the plurality of query-response pairs based further on a size of the particular query-response pair in the cache (Col. 24 lines 62-67: “the replica” (e.g., a response to a “query”) “is removed” (is selected for pruning) “from the cache” (from cache) “in response to determining, at the first query accelerator node, that the data item meets an eviction criterion, wherein the eviction criterion comprises one or more of: (a) a criterion based on a time at which the data item was accessed” (b) a time-to-live criterion, (c) a size criterion” (based on a size associated with the “query” (query) “data item” (response))).
For obviousness to combine Byron et al. in view of Kotte et al. and Muniswamy Reddy et al. see claim 15.
Claim(s) 9 is/are rejected under 35 U.S.C. 103 as being unpatentable over Byron et al. in view of Kotte et al., and further in view of RAHEJA et al. (US 2025/0258818).
Regarding claim 9, Byron et al. in view of Kotte et al. do not specifically disclose the method as in claim 1, further comprising:
sending a new query for input to the language model, when the new query does not match any queries in the cache.
RAHEJA et al. do teach:
the method as in claim 1, further comprising:
sending a new query for input to the language model, when the new query does not match any queries in the cache (Page 8 column 1 lines 34+: “performing, by the device, a large language model” (sending a new query to a language model) “operation to generate an answer to the received query responsive to a determination that no question and answer pair in the cache” (when no entry in the cache) “of question and answer pairs meets the threshold similarity” (matches the “received query” (the new query)) “level for the information contained in the set of embeddings”).
It would have therefore been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the “CACHED ANSWERS” “LLM” system and method of RAHEJA et al. into the “QUESTION/ANSWER CACHING LOGIC” of Byron et al. would enable the combined systems and their associated methods to perform in combination as they do separately and to further enable Byron et al. in view of Kotte et al. to enhance its “cache” capacity by adding new “frequently” “question and answer pairs” so as to help utilize its “cache” to provide prompt real time responses and avoid using “costly” “large language models” to provide “answer[s]” to “question[s]” as disclosed in RAHEJA et al. ¶ 0042 last sentence.
Conclusion
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to FARZAD KAZEMINEZHAD whose telephone number is (571)270-5860. The examiner can normally be reached 10:30 am to 11:30 pm.
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, Paras D. Shah can be reached at (571) 270-1650. 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.
/Farzad Kazeminezhad/
Art Unit 2653
May 30th 2026.
Prosecution Insights