METHODS AND APPARATUS FOR END-TO-END ENTERPRISE-BASEDGENERATIVE ARTIFICIAL INTELLIGENCE (GenAI)

Abstract

Apparatus includes interface circuitry, machine-readable instructions, and at least one processor circuit to be programmed by the machine-readable instructions to access a prompt received at a user device, the prompt associated with a document, determine a compute requirement associated with the prompt, transmit the document to a server when the compute requirement exceeds a threshold, and receive an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.

Description

METHODS AND APPARATUS FOR END-TO-END ENTERPRISE-BASEDGENERATIVE ARTIFICIAL INTELLIGENCE (GenAI)RELATED APPLICATION

[0001] This patent claims the benefit of PCT Application No. PCT / CN2025 / 075245, which was filed on January 26, 2025. PCT Patent Application No. PCT / CN2025 / 075245 is hereby incorporated herein by reference in its entirety. Priority to PCT Application No. PCT / CN2025 / 075245 is hereby claimed.BACKGROUND

[0002] Artificial intelligence (AI) assistants using Generative AI (GenAI) provide support to users with tasks such as natural language understanding, content generation, and / or task automation. GenAI relies on algorithms trained to predict data sequences based on training information, with Large Language Models (LLMs) representing a subset of GenAI focusing on image and text generation.BRIEF DESCRIPTION OF THE DRAWINGS

[0003] FIG. 1 is a block diagram of an example known implementation of a Retrieval Augmented Generation (RAG) pipeline using offline stages and active stages.

[0004] FIG. 2 is a block diagram of an example implementation of server communicator circuitry constructed in accordance with teachings of this disclosure to implement end-to-end enterprise-based RAG.

[0005] FIG. 3 is a block diagram of an example implementation of the server communicator circuitry of FIG. 2 on a user device associated with end-to-end enterprise-based RAG.

[0006] FIG. 4 is a flowchart representative of example machine-readable instructions and / or example operations that may be executed, instantiated, and / or performed by example programmable circuitry to implement the example server communicator circuitry of FIG. 2.

[0007] FIG. 5 is a flowchart representative of example machine-readable instructions and / or example operations that may be executed, instantiated, and / or performed by the example server communicator circuitry of FIG. 2 to perform local processing on a user device or generate a request to the server based on a type of prompt received.

[0008] FIG. 6 is a flowchart representative of example machine-readable instructions and / or example operations that may be executed, instantiated, and / or performed by the example server communicator circuitry of FIG. 2 to process a Question / Answer (Q / A) pairs request.

[0009] FIG. 7 is a block diagram of an example processing platform including programmable circuitry structured to execute, instantiate, and / or perform the example machine readable instructions and / or perform the example operations of FIGS. 4-6 to implement the example server communicator circuitry of FIG. 2.

[0010] FIG. 8 is a block diagram of an example implementation of the programmable circuitry of FIG. 7.

[0011] FIG. 9 is a block diagram of another example implementation of the programmable circuitry of FIG. 7.

[0012] FIG. 10 is a block diagram of an example software / firmware / instructions distribution platform (e.g., one or more servers) to distribute software, instructions, and / or firmware (e.g., corresponding to the example machine readable instructions of FIGS. 4-6) to client devices associated with end users and / or consumers (e.g., for license, sale, and / or use) , retailers (e.g., for sale, re-sale, license, and / or sub-license) , and / or original equipment manufacturers (OEMs) (e.g., for inclusion in products to be distributed to, for example, retailers and / or to other end users such as direct buy customers) .

[0013] In general, the same reference numbers will be used throughout the drawing (s) and accompanying written description to refer to the same or like parts. The figures are not necessarily to scale.DETAILED DESCRIPTION

[0014] Retrieval Augmented Generation (RAG) is a Generative Artificial Intelligence (GenAI) framework that improves GenAI by allowing machine learning model engines (e.g., Large Language Models (LLMs) , Large Vision Models (LVMs) , Large Multimodal Models (LMMs) , etc. ) to integrate private enterprise data with publicly available information. RAG models allow for the combination of retrieval-based methods with generative models to obtain contextually accurate and semantically rich outputs. RAG can search, query, and / or provision relevant data associated with a user-based query to generate an enriched, contextual prompt that is provided to the machine learning model engine for further processing. RAG-based methods can be classified into vector-based RAG and graph-based RAG. Vector-based RAG calculates semantic similarity between query and document embedding (s) , allowing for efficient retrieval of generally related content (e.g., document searches, product recommendations, etc. ) , while graph-based RAG leverages knowledge graphs, providing more precise contextual information (e.g., for tasks such as question answering, knowledge base completion, etc. ) .

[0015] RAG-based methods can be implemented on computing systems that can support AI-related workloads (e.g., computational tasks involved in developing, training, and / or deploying artificial intelligence models, etc. ) requiring significant computational power, memory, and storage (e.g., to support large datasets, complex algorithms, etc. ) . AI-related workloads can include model training, model inference, data preprocessing, Natural Language Processing (NLP) , and / or computer vision. AI-based personal computers (PCs) include hardware features to facilitate efficient AI workload processing, including integrated neural processing units (NPUs) , enhanced memory architectures to handle AI model data, optimized instruction sets for AI operations, power management features for AI workloads, and / or hardware-level security features for AI model protection. Such features on AI PCs allow a greater number of AI workloads to run locally on personal computers, reducing the need for cloud processing and improving privacy and latency for AI applications.

[0016] While an AI PC can be used to implement RAG-based methods, each enterprise might also have an existing server and / or an on-premise cluster that stores data that may be relevant to generating an accurate response to a user query and / or any other GenAI-related task. In particular, large quantities of enterprise data can be stored on the server side and / or other locations (e.g., SharePoint, OneDrive, etc. ) . Such data can be useful in performing GenAI-related tasks that require the use of diverse sources of information. However, current implementations of RAG-based methods are limited to direct applications on local devices (e.g., AI PCs) , with separate implementations on external device (s) and / or network (s) that are not in direct communication with the local device (s) (e.g., servers, server clusters, etc. ) , thereby limiting the potential applicability of RAG to AI-related workloads that could benefit from access to a diverse array of other externally-located databases.

[0017] Methods and apparatus disclosed herein introduce an efficient approach to implementing RAG-based methods using both local devices (e.g., AI PCs) and enterprise-based hardware resource (s) . Examples disclosed herein optimize the utilization of existing enterprise-grade resources for improving the accuracy of GenAI. For example, methods and apparatus disclosed herein improve AI assistant capabilities across diverse hardware configurations, ensuring seamless document management and / or query resolution through an interconnected system of local device (e.g., AI PC) and server-side resources. In examples disclosed herein, a RAG-based AI assistant is deployed on both an AI PC and an enterprise server, allowing for seamless integration and efficient querying regardless of where the documents are located (e.g., locally or externally) . In examples disclosed herein, numerous hardware resources available on the server-side can be utilized as part of AI assistant-based task completions (e.g., a more powerful embedding model, a re-ranker model, a large language model, etc. ) .

[0018] For local document inquiries, a local-based AI assistant (e.g., on the AI PC) can be used as needed, eliminating the need for network connectivity when external resources (e.g., associated with the server and / or cluster) are not necessary. In examples disclosed herein, user-based feedback accumulated at the local device can be shared with external sources (e.g., server (s) ) to improve RAG-based machine learning model engine performance. Methods and apparatus disclosed herein further allow for computationally intensive tasks (e.g., complex parsing tasks, etc. ) to be performed on the server instead of on the local device (e.g., based on a compute requirement threshold) , thereby reducing the amount of time for the task to be completed due to the higher-level resource availability on the server as compared to the local device.

[0019] FIG. 1 is a block diagram 100 of an example known implementation of a Retrieval Augmented Generation (RAG) pipeline 103 using an example offline stage 105 and an example active stage 110. In examples disclosed herein, the offline stage 105 begins with document ingestion (e.g., load document 115) and document parsing (e.g., parse document 120) . For example, raw documents from various sources (e.g., such as PDFs, text files, website pages, etc. ) undergo cleaning and normalization to remove formatting artifacts and / or handle special characters. During parsing, RAG-based methods can be used to partition the text into manageable sections. For example, RAG can be described using three different stages, including ingestion, retrieval, and synthesis / response generation. Ingestion includes receiving prompts and / or documents and dividing the prompts and / or documents into smaller, more manageable segments. The segments can be defined based on a fixed size, number of characters, number of sentences, and / or any other type of segment-based selection for reducing noise while maintaining integrity of the context (e.g., fixed-size chunking, context-aware chunking, etc. ) .

[0020] Subsequently, the RAG pipeline 103 generates embeddings (e.g., generate embedding 125, 160) of received prompts (e.g., user query 155) and / or documents as part of ingestion (e.g., during the RAG offline stage 105 and / or the RAG active stage 110) . In examples disclosed herein, the RAG pipeline 103 encodes each segment of the prompt and / or document into an embedding vector for retrieval (e.g., using an embedding model 135) . In particular, the RAG pipeline 103 transforms the document (s) and / or prompt (s) to a format that can be compared for relevance. In some examples, RAG selects a type of embedding based on a given task (e.g., sparse embedding, semantic embedding such as Bidirectional Encoder Representations from Transformers (BERT) , SentenceBERT, etc. ) . While sparse embedding allows for a lexical-based matching of the prompt (s) with the received document (s) (e.g., keyword matching) , semantic embedding is more appropriate for RAG-based embedding due to a focus on both context and meaning, resulting in semantically rich embedding that captures contextual nuances.

[0021] In the example of FIG. 1, the RAG pipeline 103 stores the embedding (s) in a vector database (e.g., store in vector database 130) during the offline stage 105. As such, the RAG pipeline 103 can retrieve information that is most relevant to a received prompt (e.g., user query 150) during the active stage 110 (e.g., using a vector similarity search 165) . In examples disclosed herein, the user query 150 can be a search query, a question associated with a Question / Answer (Q / A) task, a dialog utterance, and / or any other type of prompt. In some examples, the RAG pipeline 103 uses a vector database (e.g., vector database 140 such as Pinecone, Weaviate, Milvus, FAISS, Chroma, etc. ) to identify and retrieve relevant information related to the user query 155 during the retrieval stage of RAG. However, any other type of database can be used, including a graph database or a regular Structured Query Language (SQL) database. In examples disclosed herein, the vector database is used when queries are embedded for generating dense vector embeddings and / or sparse embeddings, such that the RAG pipeline 103 performs a search based on term frequency (e.g., Term Frequency-Inverse Document Frequency (TF-IDF) ) and / or semantic similarity.

[0022] In some examples, the RAG pipeline 103 performs a re-ranking of information retrieved based on the vector similarity search 165 (e.g., re-rank top results 170) . For example, the RAG pipeline 103 re-orders K retrieved passages to pick the most relevant passages based on the user query 155. The RAG pipeline 103 can implement a re-ranker model (e.g., re-ranker model 145) to apply re-ranking techniques such as, but not limited to lexical re-ranking (e.g., re-ranking based on lexical similarity between the query and retrieved information as determined using TF-IDF vectors) , semantic re-ranking (e.g., re-ranking based on semantic assessment using BERT or other transformer-based models) , and Learning-to-Rank (LTR) re-ranking (e.g., using a trained model to rank documents based on features extracted from the user query 155 and the documents) . In the example of FIG. 1, the resulting re-ranking is followed by assembly of the input prompt (e.g., assemble input prompt 175 to combine the retrieved context with the user query and system instructions) , which is subsequently provided to the machine learning model engine (e.g., LLM / LVM / LMM 150) to generate an informed response to the user (e.g., response 180) based on the initial user query 155.

[0023] FIG. 2 is a block diagram 200 of an example implementation of server communicator circuitry 215 constructed in accordance with teachings of this disclosure to implement end-to-end enterprise-based RAG. In the example of FIG. 2, the server communicator circuitry 215 is implemented on a user device 205 (e.g., any local device such as an AI PC, etc. ) and is in communication with a server 210 (e.g., any source external to the local device, including an enterprise server, an on-premise cluster, etc. ) . In examples disclosed herein, the server communicator circuitry 215 is also in communication with local RAG initiator circuitry 220, which implements the RAG pipeline 103 of FIG. 1 for local RAG-based requests (e.g., as part of an AI assistant) .

[0024] The local RAG initiator circuitry 220 of FIG. 2 may be instantiated (e.g., creating an instance of, bring into being for any length of time, materialize, implement, etc. ) by programmable circuitry. For example, programmable circuitry may be implemented by a Central Processing Unit (CPU) executing first instructions, a field programmable gate array, a programmable logic device (PLD) , a generic array logic (GAL) device, a programmable array logic (PAL) device, a complex programmable logic device (CPLD) , a simple programmable logic device (SPLD) , a microcontroller (MCU) , a programmable system on chip (PSoC) , etc. Additionally or alternatively, the local RAG initiator circuitry 220 of FIG. 2 may be instantiated (e.g., creating an instance of, bring into being for any length of time, materialize, implement, etc. ) by (i) an Application Specific Integrated Circuit (ASIC) and / or (ii) a Field Programmable Gate Array (FPGA) (e.g., another form of programmable circuitry) structured and / or configured in response to execution of second instructions to perform operations corresponding to the first instructions. It should be understood that some or all of the circuitry of FIG. 2 may, thus, be instantiated at the same or different times. Some or all of the circuitry of FIG. 2 may be instantiated, for example, in one or more threads executing concurrently on hardware and / or in series on hardware. Moreover, in some examples, some or all of the circuitry of FIG. 2 may be implemented by microprocessor circuitry executing instructions and / or FPGA circuitry performing operations to implement one or more virtual machines and / or containers.

[0025] Methods and apparatus disclosed herein optimize the utilization of existing enterprise-grade resources (e.g., associated with the server 210) to determine whether to perform RAG-related tasks on the local device (e.g., user device 205) and / or on the server 210. As such, methods and apparatus disclosed herein improve AI assistant capabilities across diverse hardware configurations, ensuring seamless document management and / or query resolution through an interconnected system of local device and server-side resources. In the example of FIG. 2, the server communicator circuitry 215 determines whether to implement the local RAG initiator circuitry 220 based on the location of relevant document (s) associated with a prompt (e.g., user query 155 of FIG. 1) . In some examples, the server communicator circuitry 215 identifies queries associated with local document (s) (e.g., stored on the user device 205) and prompts the local RAG initiator circuitry 220 to output a result (e.g., response 180) . Since the local RAG initiator circuitry 220 can perform any tasks associated with locally stored document (s) , this eliminates the need for network connectivity (e.g., since communication with the server 210 to perform the task is not necessary) . However, even when the document (s) needed to complete a RAG-related task are located on the server 210, the server communicator circuitry 215 permits efficient querying by triggering the user request (e.g., user query 155) to be transmitted from the user device 205 to the server 210 (e.g., such as when a user seeks assistance regarding document (s) stored on the server 210) .

[0026] For example, more hardware resources can be available on the server-side, allowing for compute-intensive tasks (e.g., complex parsing tasks, etc. ) to be performed on the server 210 instead of on the local device (e.g., user device 205) . As described in more detail in connection with FIG. 3, the server communicator circuitry 215 assesses the level of computational complexity associated with a given user query, transmitting the request to the server 210 instead of initiating local RAG-based evaluation of the user request (e.g., to expedite the processing) . For example, the server 210 can have access to RAG pipeline (s) with more powerful embedding model (s) (e.g., embedding model 135) , re-ranker model (s) (e.g., re-ranker model 145) , as well as machine learning model engines (e.g., LLM / LVM / LMM 150) as compared to model (s) implemented on the user device 205 (e.g., in connection with the local RAG initiator circuitry 220) . In examples disclosed herein, when users have a compute-intensive request (e.g., questions that need multi-modality models to generate an answer) , the user device 205 (e.g., via the server communicator circuitry 215) can offload the request to the server-side (e.g., uploading a large image and asking questions related to the image) . For example, a local AI PC (e.g., user device 205) can require up to 31 seconds to generate an answer to a complex user query, while methods and apparatus disclosed herein allow for the generation of an answer under a total of 1.5 seconds by implementing enterprise-based resources (e.g., on the server 210) , resulting in an increase in computing speed by approximately 20 times.

[0027] In the example of FIG. 2, the server communicator circuitry 215 can prompt the server 210 to perform tasks associated with the processing of an LLM / LMM-based query (e.g., LLM / LMM query 225) and the uploading of Question / Answer (Q / A) pairs (e.g., user corrected Q / Apairs upload 230) . For example, as users engage with the local AI assistant (e.g., associated with the local RAG initiator circuitry 220) on the user device 205, user feedback continuously improves in accuracy over time. In examples disclosed herein, the server communicator circuitry 215 can share accumulated Q / Apairs (e.g., refined through user corrections) via the server 210, enhancing collaborative efficiency. As described in connection with FIG. 3, the server communicator circuitry 215 initiates a request prompting the server 210 to load the Q / Apairs in a vector database (e.g., located on the server 210 in connection with a server-based RAG pipeline) . For example, the server 210 can use the Q / Apairs to fine-tune LLMs (e.g., resulting in a fine-tuned model 250) , improving their performance on RAG-related tasks (e.g., outputting responses to user queries) . In examples disclosed herein, the server communicator circuitry 215 receives fine-tuned model download (s) (e.g., fine-tuned model download 235) from the server 210 and loads the fine-tuned model (s) (e.g., LLM, LVM, LMM, etc. ) on the user device 205 (e.g., allowing the local RAG initiator circuitry 220 to implement the fine-tuned model (s) as part of the local device-based RAG pipeline) .

[0028] In examples disclosed herein, the server communicator circuitry 215 can also retrieve information from the server 210 associated with server-based RAG pipeline results. For example, when the server communicator circuitry 215 delegates complex parsing tasks (e.g., complex parsing 255) with a high compute requirement to the server 210 (e.g., tasks to be performed by the server-based RAG pipeline instead of the local device-based RAG pipeline) , the server communicator circuitry 215 can retrieve information associated with the completed tasks (e.g., parsed document retrieval 240) . For example, document parsing has a significant impact on overall RAG accuracy. For intricate documents, the user device 205 can implement the server communicator circuitry 215 to leverage server-side resources for complex parsing, with the parsed documents downloaded to the user device 205 to facilitate local access on demand. In some examples, the server communicator circuitry 215 also delegates complex embedding tasks to the server 210 (e.g., using the embedded model 260) and subsequently retrieves the resulting outputs (e.g., embedded document retrieval 245) from the server 210. In some examples, the server communicator circuitry 215 determines whether both platforms (e.g., user device 205 and server 210) use identical embedding models and downloads embedding data from the server 210 for implementation on the user device 205 (e.g., via the local RAG initiator circuitry 220) . In examples disclosed herein, the RAG pipeline (s) implemented on the user device 205 and the server 210 may be the same or different. For example, while the RAG pipeline implemented on the user device 205 can include a BAAI (base) general embedding model (e.g., model that transforms any given text into a 768-dimensional vector) , the server 210 can include a BAAI (large) general embedding model (e.g., model that transforms any given text into a 1024-dimensional vector) , such that the number of parameters are different when using one embedding model as compared to another embedding model.

[0029] As previously mentioned, the local RAG initiator circuitry 220 can perform local RAG-based tasks (e.g., using the RAG pipeline 103 of FIG. 1) when the server communicator circuitry 215 determines that a user query (e.g., user query 155) is associated with document (s) stored locally on the user device 205. For example, the local RAG initiator circuitry 220 can perform ingestion and processing of local document (s) as described in connection with FIG. 1, allowing files to be processed (e.g., stored in the local vector database 140) before a user query is received. In some examples, the server communicator circuitry 215 can also transmit documents stored on the user device 205 to the server 210 to allow the server-based RAG pipeline to ingest and process the document (s) . As such, if the server communicator circuitry 215 identifies a user query that is compute-intensive and requires the application of locally stored documents, these documents are available to the server 210 to complete more resource-intensive tasks (e.g., complex parsing, etc. ) , allowing the server communicator circuitry 215 to retrieve the final output (s) without implementing the local RAG initiator circuitry 220 (e.g., reducing processing times) . In some examples, the server communicator circuitry 215 transmits the received user query directly to the server 210. In some examples, the local RAG initiator circuitry 220 performs vectorization of the user query and / or the document located on the user device before the server communicator circuitry 215 transmits the vectorized user query and / or document to the server 210 for further processing. For example, the server communicator circuitry 215 can send the results of any portion of the local RAG pipeline output (e.g., vectorized output, embedded output, etc. ) obtained using the local RAG initiator circuitry 220 to the server 210.

[0030] In some examples, the apparatus includes means for vectorizing a document by implementing a RAG pipeline located on a user device. For example, the means for vectorizing a document may be implemented by local RAG initiator circuitry 220. In some examples, the local RAG initiator circuitry 220 may be instantiated by programmable circuitry such as the example programmable circuitry 712 of FIG. 7. For instance, the local RAG initiator circuitry 220 may be instantiated by the example microprocessor 800 of FIG. 8 executing machine executable instructions such as those implemented by at least block 540 of FIG. 5. In some examples, the local RAG initiator circuitry 220 may be instantiated by hardware logic circuitry, which may be implemented by an ASIC, XPU, or the FPGA circuitry 900 of FIG. 9 structured to perform operations corresponding to the machine readable instructions. Additionally or alternatively, the local RAG initiator circuitry 220 may be instantiated by any other combination of hardware, software, and / or firmware. For example, the local RAG initiator circuitry 220 may be implemented by at least one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, an XPU, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to execute some or all of the machine readable instructions and / or to perform some or all of the operations corresponding to the machine readable instructions without executing software or firmware, but other structures are likewise appropriate.

[0031] FIG. 3 is a block diagram 300 of an example implementation of server communicator circuitry 215 constructed in accordance with teachings of this disclosure to implement end-to-end enterprise-based RAG. The server communicator circuitry 215 of FIG. 3 may be instantiated (e.g., creating an instance of, bring into being for any length of time, materialize, implement, etc. ) by programmable circuitry. For example, programmable circuitry may be implemented by a Central Processing Unit (CPU) executing first instructions, a field programmable gate array, a programmable logic device (PLD) , a generic array logic (GAL) device, a programmable array logic (PAL) device, a complex programmable logic device (CPLD) , a simple programmable logic device (SPLD) , a microcontroller (MCU) , a programmable system on chip (PSoC) , etc. Additionally or alternatively, the server communicator circuitry 215 of FIG. 3 may be instantiated (e.g., creating an instance of, bring into being for any length of time, materialize, implement, etc. ) by (i) an Application Specific Integrated Circuit (ASIC) and / or (ii) a Field Programmable Gate Array (FPGA) (e.g., another form of programmable circuitry) structured and / or configured in response to execution of second instructions to perform operations corresponding to the first instructions. It should be understood that some or all of the circuitry of FIG. 3 may, thus, be instantiated at the same or different times. Some or all of the circuitry of FIG. 3 may be instantiated, for example, in one or more threads executing concurrently on hardware and / or in series on hardware. Moreover, in some examples, some or all of the circuitry of FIG. 3 may be implemented by microprocessor circuitry executing instructions and / or FPGA circuitry performing operations to implement one or more virtual machines and / or containers.

[0032] In the example of FIG. 3, the server communicator circuitry 215 includes example user device input identifier circuitry 310, example query analyzer circuitry 315, example request generator circuitry 320, example server output identifier circuitry 325, and an example data storage 330. In the example of FIG. 3, the user device input identifier circuitry 310, the query analyzer circuitry 315, the request generator circuitry 320, the server output identifier circuitry 325, and the data storage 330 are in communication via an example bus 340.

[0033] The user device input identifier circuitry 310 identifies input (s) received at the user device 205 associated with user queries and / or documents. In some examples, the user device input identifier circuitry 310 identifies the type (s) of document (s) received as part of a user query (e.g., text, images, etc. ) . In some examples, the user device input identifier circuitry 310 identifies information associated with the local RAG initiator circuitry 220. For example, the user device input identifier circuitry 310 identifies a type of embedding model, a type of re-ranker model, and / or a type of machine learning model engine (e.g., LLM, LVM, LMM) associated with the local RAG pipeline (e.g., RAG pipeline 103 of FIG. 1) . In some examples, the user device input identifier circuitry 310 determines whether the model (s) implemented by the local RAG initiator circuitry 220 match and / or differ from the model (s) implemented by the server-based RAG pipeline (e.g., RAG pipeline on the server 210) .

[0034] In some examples, the apparatus includes means for identifying an input. For example, the means for identifying an input may be implemented by user device input identifier circuitry 210. In some examples, the user device input identifier circuitry 210 may be instantiated by programmable circuitry such as the example programmable circuitry 712 of FIG. 7. For instance, the user device input identifier circuitry 210 may be instantiated by the example microprocessor 800 of FIG. 8 executing machine executable instructions such as those implemented by at least block 425 of FIG. 4. In some examples, the user device input identifier circuitry 210 may be instantiated by hardware logic circuitry, which may be implemented by an ASIC, XPU, or the FPGA circuitry 900 of FIG. 9 structured to perform operations corresponding to the machine readable instructions. Additionally or alternatively, the user device input identifier circuitry 210 may be instantiated by any other combination of hardware, software, and / or firmware. For example, the user device input identifier circuitry 210 may be implemented by at least one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, an XPU, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to execute some or all of the machine readable instructions and / or to perform some or all of the operations corresponding to the machine readable instructions without executing software or firmware, but other structures are likewise appropriate.

[0035] The query analyzer circuitry 315 performs an assessment of a user query and / or prompt to determine whether to implement the local RAG-based pipeline (e.g., using local RAG initiator circuitry 220) and / or send the user query to the server 210 (e.g., to implement the server-based RAG pipeline) . In examples disclosed herein, the query analyzer circuitry 315 identifies a compute requirement associated with the received prompt (e.g., user query 155) . For example, the query analyzer circuitry 315 determines a threshold compute requirement associated with user query-related tasks that can be performed using the local RAG initiator circuitry 220. As such, any tasks that require compute resources that exceed the compute requirement threshold for implementation of the local RAG pipeline (e.g., complex parsing tasks, etc. ) result in the request being forwarded to the server 210 (e.g., as described in connection with the request generator circuitry 320) . However, when the query analyzer circuitry 315 determines that task (s) associated with the received user query fall below the compute requirement threshold (e.g., estimated time of completion using the local RAG pipeline does not significantly vary from the estimated time of completion using the server-based RAG pipeline) , the query analyzer circuitry 315 prompts the request generator circuitry 320 to submit the user query and / or prompt for further processing to the local RAG initiator circuitry 220.

[0036] In some examples, the query analyzer circuitry 315 determines that the local RAG initiator circuitry 220 output (e.g., response 180) is not satisfactory (e.g., based on a lack of accuracy, etc. ) . In such examples, the query analyzer circuitry 315 determines whether the relevant document (s) (e.g., submitted as part of the query) are stored on the server 210. If the server does not have copies of such documents, the query analyzer circuitry 315 determines that both the user query and associated files need to be transmitted to the server 210 (e.g., using the request generator circuitry 320) to obtain an answer to the user query using server-based resources. In some examples, the query analyzer circuitry 315 identifies that relevant document (s) associated with the query have already been shared between the user device 205 and the server 210. As such, the query analyzer circuitry 315 prompts the request generator circuitry 320 to transmit only the question associated with the user query without additional documents (e.g., when the documents have been received by the server-based RAG pipeline during the RAG ingestion stage) . However, if the query analyzer circuitry 315 determines that relevant document (s) are accessible to the server 210 (e.g., a document on OneDrive accessible to both the user device 205 and the server 210) , the query analyzer circuitry 315 identifies (1) the question associated with the user query and (2) the file path associated with the document to transmit to the server 210 (e.g., using the request generator circuitry 320) , allowing the server 210 to ingest and process the document directly from the server 210. Subsequently, the server output identifier circuitry 325 receives the final answer obtained by the server-based RAG pipeline.

[0037] In some examples, the query analyzer circuitry 315 can also initiate vectorization of the received user query and / or document (e.g., using the local RAG initiator circuitry 220) prior to transmitting the vectorized document to the server 210 (e.g., using the request generator circuitry 320) and / or prior to determining the compute requirement associated with the received user query. For example, the query analyzer circuitry 315 can determine that vectorizing the document locally prior to transmission to the server 210 will reduce the overall processing time (s) (e.g., for obtaining a response using the server-based RAG pipeline) . As such, the query analyzer circuitry 315 can perform the sequence of steps associated with obtaining the RAG-based output in any order (e.g., transmitting the query and / or documents to the server 210 directly, vectorizing the query and / or documents prior to transmission to the server 210, etc. ) . In some examples, the query analyzer circuitry 315 can evaluate the compute requirement of the user query before and / or after initiating local RAG-based vectorization of the user query and / or query documents.

[0038] In some examples, the apparatus includes means for assessing a query. For example, the means for assessing a query may be implemented by query analyzer circuitry 315. In some examples, the query analyzer circuitry 315 may be instantiated by programmable circuitry such as the example programmable circuitry 712 of FIG. 7. For instance, the query analyzer circuitry 315 may be instantiated by the example microprocessor 800 of FIG. 8 executing machine executable instructions such as those implemented by at least block (s) 525, 530 of FIG. 5. In some examples, the query analyzer circuitry 315 may be instantiated by hardware logic circuitry, which may be implemented by an ASIC, XPU, or the FPGA circuitry 900 of FIG. 9 structured to perform operations corresponding to the machine readable instructions. Additionally or alternatively, the query analyzer circuitry 315 may be instantiated by any other combination of hardware, software, and / or firmware. For example, the query analyzer circuitry 315 may be implemented by at least one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, an XPU, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to execute some or all of the machine readable instructions and / or to perform some or all of the operations corresponding to the machine readable instructions without executing software or firmware, but other structures are likewise appropriate.

[0039] The request generator circuitry 320 generates one or more request (s) to the server 210. For example, the request generator circuitry 320 transmits a user query and / or document (s) associated with the query to the server 210 with a request to process the user query and / or document (s) to obtain a final response (e.g., using a server-based RAG pipeline) . As previously described, the request generator circuitry 320 can generate a request to the server 210 to store document (s) received locally on the user device 205. As such, when document (s) are available directly on the server, the request generator circuitry 320 can send the question (s) associated with the user query to the server 210 without providing the additional document (s) . As described in connection with FIG. 2, the request generator circuitry 320 can send a machine learning model engine query (e.g., LLM / LMM query) to the server 210 to initiate a request for a response to the query (e.g., received at the user device 205) . In some examples, the request generator circuitry 320 provides user-corrected Question / Answer (Q / A) pairs to the server 210, periodically providing user feedback to the server 210 to facilitate fine-tuning of the server-based machine learning model engine (e.g., LLM, etc. ) . In some examples, the request generator circuitry 320 transmits user feedback to the server 210 for (1) loading into a vector database of the server 210 or (2) performing fine-tuning of the LLM to generate a fine-tuned model (e.g., fine-tuned model 250) . For example, user feedback provided by users of the user device 205 can include corrections to answers (e.g., response (s) 180 of FIG. 1) resulting from machine learning model engine output (s) using the local RAG pipeline (e.g., controlled by the local RAG initiator circuitry 220) . In examples disclosed herein, server-based computational resources can be used to fine-tune the machine learning model engine to incorporate the corrected user feedback. As such, the fine-tuning is performed on the server 210 instead of on the user device 205, allowing the server output identifier circuitry 325 to retrieve the fine-tuned model (e.g., fine-tuned model download 235 of FIG. 2) from the server 210. In examples disclosed herein, the frequency of fine-tuning can be configurable, such that the request generator circuitry 320 triggers the fine-tuning request to the server 210 when a total of 200 user-provided corrections and / or feedback inputs are received.

[0040] In some examples, the apparatus includes means for ranking information. For example, the means for ranking information may be implemented by ranker circuitry 140. In some examples, the ranker circuitry 140 may be instantiated by programmable circuitry such as the example programmable circuitry 712 of FIG. 7. For instance, the ranker circuitry 140 may be instantiated by the example microprocessor 800 of FIG. 8 executing machine executable instructions such as those implemented by at least block 420 of FIG. 4. In some examples, the ranker circuitry 140 may be instantiated by hardware logic circuitry, which may be implemented by an ASIC, XPU, or the FPGA circuitry 900 of FIG. 9 structured to perform operations corresponding to the machine readable instructions. Additionally or alternatively, the ranker circuitry 140 may be instantiated by any other combination of hardware, software, and / or firmware. For example, the ranker circuitry 140 may be implemented by at least one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, an XPU, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to execute some or all of the machine readable instructions and / or to perform some or all of the operations corresponding to the machine readable instructions without executing software or firmware, but other structures are likewise appropriate.

[0041] The server output identifier circuitry 325 retrieves and / or identifies output (s) from the server 210. In examples disclosed herein, the server output identifier circuitry 325 retrieves the fine-tuned model (e.g., fine-tuned model 250) from the server 210 for use on the user device 205 (e.g., as part of the local RAG-based pipeline that implements the machine learning model engine) . In some examples, the server output identifier circuitry 325 identifies output (s) associated with answer (s) to user queries processed by the server 210 (e.g., using the server-based RAG pipeline) , including results of complex parsing tasks (e.g., complex parsing 255 of FIG. 2) . For example, the server output identifier circuitry 325 retrieves the parsed document (s) (e.g., parsed document retrieval 240 of FIG. 2) and loads the parsed document (s) on the user device 205. In some examples, the server output identifier circuitry 325 retrieve (s) embedded document (s) (e.g., embedded document retrieval 245 of FIG. 2) based on results provided by an embedded model (e.g., embedded model 260 of FIG. 2) associated with the server 210. In some examples, when an embedding model on the user device 205 matches the embedding model on the server 210, the server output identifier circuitry 325 downloads embedding data from the server for use on the user device 205.

[0042] In some examples, the apparatus includes means for receiving an output from the server. For example, the means for receiving an output from the server may be implemented by server output identifier circuitry 325. In some examples, the server output identifier circuitry 325 may be instantiated by programmable circuitry such as the example programmable circuitry 712 of FIG. 7. For instance, the server output identifier circuitry 325 may be instantiated by the example microprocessor 800 of FIG. 8 executing machine executable instructions such as those implemented by at least block 420 of FIG. 4. In some examples, the server output identifier circuitry 325 may be instantiated by hardware logic circuitry, which may be implemented by an ASIC, XPU, or the FPGA circuitry 900 of FIG. 9 structured to perform operations corresponding to the machine readable instructions. Additionally or alternatively, the server output identifier circuitry 325 may be instantiated by any other combination of hardware, software, and / or firmware. For example, the server output identifier circuitry 325 may be implemented by at least one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, an XPU, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to execute some or all of the machine readable instructions and / or to perform some or all of the operations corresponding to the machine readable instructions without executing software or firmware, but other structures are likewise appropriate.

[0043] The data storage 330 can be used to store any information associated with the user device input identifier circuitry 310, the query analyzer circuitry 315, the request generator circuitry 320, and / or the server output identifier circuitry 325. The data storage 330 of the illustrated example of FIG. 3 can be implemented by any memory, storage device and / or storage disc for storing data such as flash memory, magnetic media, optical media, etc. Furthermore, the data stored in the data storage 330 can be in any data format such as binary data, comma delimited data, tab delimited data, structured query language (SQL) structures, image data, etc.

[0044] While an example manner of implementing the server communicator circuitry 215 of FIG. 2 is illustrated in FIG. 3, one or more of the elements, processes and / or devices illustrated in FIG. 3 may be combined, divided, re-arranged, omitted, eliminated and / or implemented in any other way. Further, the example user device input identifier circuitry 310, the example query analyzer circuitry 315, the example request generator circuitry 320, the example server output identifier circuitry 325, and / or, more generally, the example server communicator circuitry 215 of FIG. 2 may be implemented by hardware, software, firmware and / or any combination of hardware, software and / or firmware. Thus, for example, any of the example user device input identifier circuitry 310, the example query analyzer circuitry 315, the example request generator circuitry 320, the example server output identifier circuitry 325, and / or, more generally, the example server communicator circuitry 215 of FIG. 2 could be implemented by programmable circuitry, processor circuitry, analog circuit (s) , digital circuit (s) , logic circuit (s) , programmable processor (s) , programmable microcontroller (s) , graphics processing unit (s) (GPU (s) ) , digital signal processor (s) (DSP (s) , ASIC (s) ) , programmable logic device (s) (PLD (s) ) , vision processing units (VPUs) , and / or field programmable logic device (s) (FPLD (s) ) such as FPGAs in combination with machine readable instructions (e.g., firmware or software) . Further still, the server communicator circuitry 215 of FIG. 2 may include one or more elements, processes, and / or devices in addition to, or instead of, those illustrated in FIG. 2, and / or may include more than one of any or all of the illustrated elements, processes and devices.

[0045] Flowcharts representative of example machine readable instructions, which may be executed by programmable circuitry to implement and / or instantiate the server communicator circuitry 215 of FIG. 2 and / or representative of example operations which may be performed by programmable circuitry to implement and / or instantiate the server communicator circuitry 215 of FIG. 2, are shown in FIGS. 4, 5, and / or 6. The machine readable instructions may be one or more executable programs or portion (s) of one or more executable programs for execution by programmable circuitry, such as the programmable circuitry 712 shown in the example processor platform 700 discussed below in connection with FIG. 7 and / or may be one or more function (s) or portion (s) of functions to be performed by the example programmable circuitry (e.g., an FPGA) discussed below in connection with FIGS. 8 and / or 9. In some examples, the machine readable instructions cause an operation, a task, etc., to be carried out and / or performed in an automated manner in the real world. As used herein, “automated” means without human involvement.

[0046] While an example manner of implementing the local RAG initiator circuitry 220 of FIG. 2 is illustrated in FIG. 2, one or more of the elements, processes and / or devices illustrated in FIG. 2 may be combined, divided, re-arranged, omitted, eliminated and / or implemented in any other way. Further, the local RAG initiator circuitry 220 of FIG. 2 may be implemented by hardware, software, firmware and / or any combination of hardware, software and / or firmware. Thus, for example, the local RAG initiator circuitry 220 of FIG. 2 could be implemented by programmable circuitry, processor circuitry, analog circuit (s) , digital circuit (s) , logic circuit (s) , programmable processor (s) , programmable microcontroller (s) , graphics processing unit (s) (GPU (s) ) , digital signal processor (s) (DSP (s) , ASIC (s) ) , programmable logic device (s) (PLD (s) ) , vision processing units (VPUs) , and / or field programmable logic device (s) (FPLD (s) ) such as FPGAs in combination with machine readable instructions (e.g., firmware or software) . Further still, the local RAG initiator circuitry 220 of FIG. 2 may include one or more elements, processes, and / or devices in addition to, or instead of, those illustrated in FIG. 2, and / or may include more than one of any or all of the illustrated elements, processes and devices.

[0047] Flowcharts representative of example machine readable instructions, which may be executed by programmable circuitry to implement and / or instantiate the local RAG initiator circuitry 220 of FIG. 2 and / or representative of example operations which may be performed by programmable circuitry to implement and / or instantiate the local RAG initiator circuitry 220 of FIG. 2, are shown in FIG. 4. The machine readable instructions may be one or more executable programs or portion (s) of one or more executable programs for execution by programmable circuitry, such as the programmable circuitry 712 shown in the example processor platform 700 discussed below in connection with FIG. 7 and / or may be one or more function (s) or portion (s) of functions to be performed by the example programmable circuitry (e.g., an FPGA) discussed below in connection with FIGS. 8 and / or 9. In some examples, the machine readable instructions cause an operation, a task, etc., to be carried out and / or performed in an automated manner in the real world. As used herein, “automated” means without human involvement.

[0048] The program may be embodied in instructions (e.g., software and / or firmware) stored on one or more non-transitory computer readable and / or machine readable storage medium such as cache memory, a magnetic-storage device or disk (e.g., a floppy disk, a Hard Disk Drive (HDD) , etc. ) , an optical-storage device or disk (e.g., a Blu-ray disk, a Compact Disk (CD) , a Digital Versatile Disk (DVD) , etc. ) , a Redundant Array of Independent Disks (RAID) , a register, ROM, a solid-state drive (SSD) , SSD memory, non-volatile memory (e.g., electrically erasable programmable read-only memory (EEPROM) , flash memory, etc. ) , volatile memory (e.g., Random Access Memory (RAM) of any type, etc. ) , and / or any other storage device or storage disk. The instructions of the non-transitory computer readable and / or machine readable medium may program and / or be executed by programmable circuitry located in one or more hardware devices, but the entire program and / or parts thereof could alternatively be executed and / or instantiated by one or more hardware devices other than the programmable circuitry and / or embodied in dedicated hardware. The machine readable instructions may be distributed across multiple hardware devices and / or executed by two or more hardware devices (e.g., a server and a client hardware device) . For example, the client hardware device may be implemented by an endpoint client hardware device (e.g., a hardware device associated with a human and / or machine user) or an intermediate client hardware device gateway (e.g., a radio access network (RAN) ) that may facilitate communication between a server and an endpoint client hardware device. Similarly, the non-transitory computer readable storage medium may include one or more mediums. Further, although the example program is described with reference to the flowcharts illustrated in FIGS. 4-6, many other methods of implementing the example server communicator circuitry 215 and / or the example local RAG initiator circuitry 220 may alternatively be used. For example, the order of execution of the blocks of the flowchart (s) may be changed, and / or some of the blocks described may be changed, eliminated, or combined. Additionally or alternatively, any or all of the blocks of the flow chart may be implemented by one or more hardware circuits (e.g., processor circuitry, discrete and / or integrated analog and / or digital circuitry, an FPGA, an ASIC, a comparator, an operational-amplifier (op-amp) , a logic circuit, etc. ) structured to perform the corresponding operation without executing software or firmware. The programmable circuitry may be distributed in different network locations and / or local to one or more hardware devices (e.g., a single-core processor (e.g., a single core CPU) , a multi-core processor (e.g., a multi-core CPU, an XPU, etc. ) ) . As used herein, programmable circuitry includes any type (s) of circuitry that may be programmed to perform a desired function such as, for example, a CPU, a GPU, a VPU, and / or an FPGA. The programmable circuitry may include one or more CPUs, one or more GPUs, one or more VPUs, and / or one or more FPGAs located in the same package (e.g., the same integrated circuit (IC) package or in two or more separate housings) , one or more CPUs, GPUs, VPUs, and / or one or more FPGAs in a single machine, multiple CPUs, GPUs, VPUs, and / or FPGAs distributed across multiple servers of a server rack, and / or multiple CPUs, GPUs, VPUs, and / or FPGAs distributed across one or more server racks. Additionally or alternatively, programmable circuitry may include a programmable logic device (PLD) , a generic array logic (GAL) device, a programmable array logic (PAL) device, a complex programmable logic device (CPLD) , a simple programmable logic device (SPLD) , a microcontroller (MCU) , a programmable system on chip (PSoC) , etc., and / or any combination (s) thereof in any of the contexts explained above.

[0049] The machine readable instructions described herein may be stored in one or more of a compressed format, an encrypted format, a fragmented format, a compiled format, an executable format, a packaged format, etc. Machine readable instructions as described herein may be stored as data (e.g., computer-readable data, machine-readable data, one or more bits (e.g., one or more computer-readable bits, one or more machine-readable bits, etc. ) , a bitstream (e.g., a computer-readable bitstream, a machine-readable bitstream, etc. ) , etc. ) or a data structure (e.g., as portion (s) of instructions, code, representations of code, etc. ) that may be utilized to create, manufacture, and / or produce machine executable instructions. For example, the machine readable instructions may be fragmented and stored on one or more storage devices, disks and / or computing devices (e.g., servers) located at the same or different locations of a network or collection of networks (e.g., in the cloud, in edge devices, etc. ) . The machine readable instructions may require one or more of installation, modification, adaptation, updating, combining, supplementing, configuring, decryption, decompression, unpacking, distribution, reassignment, compilation, etc., in order to make them directly readable, interpretable, and / or executable by a computing device and / or other machine. For example, the machine readable instructions may be stored in multiple parts, which are individually compressed, encrypted, and / or stored on separate computing devices, wherein the parts when decrypted, decompressed, and / or combined form a set of computer-executable and / or machine executable instructions that implement one or more functions and / or operations that may together form a program such as that described herein.

[0050] In another example, the machine readable instructions may be stored in a state in which they may be read by programmable circuitry, but require addition of a library (e.g., a dynamic link library (DLL) ) , a software development kit (SDK) , an application programming interface (API) , etc., in order to execute the machine-readable instructions on a particular computing device or other device. In another example, the machine readable instructions may need to be configured (e.g., settings stored, data input, network addresses recorded, etc. ) before the machine readable instructions and / or the corresponding program (s) can be executed in whole or in part. Thus, machine readable, computer readable and / or machine readable media, as used herein, may include instructions and / or program (s) regardless of the particular format or state of the machine readable instructions and / or program (s) .

[0051] The machine readable instructions described herein can be represented by any past, present, or future instruction language, scripting language, programming language, etc. For example, the machine readable instructions may be represented using any of the following languages: C, C++, Java, C#, Perl, Python, JavaScript, HyperText Markup Language (HTML) , Structured Query Language (SQL) , Swift, etc.

[0052] As mentioned above, the example operations of FIGS. 4-6 may be implemented using executable instructions (e.g., computer readable and / or machine readable instructions) stored on one or more non-transitory computer readable and / or machine readable media. As used herein, the terms non-transitory computer readable medium, non-transitory computer readable storage medium, non-transitory machine readable medium, and / or non-transitory machine readable storage medium are expressly defined to include any type of computer readable storage device and / or storage disk and to exclude propagating signals and to exclude transmission media. Examples of such non-transitory computer readable medium, non-transitory computer readable storage medium, non-transitory machine readable medium, and / or non-transitory machine readable storage medium include optical storage devices, magnetic storage devices, an HDD, a flash memory, a read-only memory (ROM) , a CD, a DVD, a cache, a RAM of any type, a register, and / or any other storage device or storage disk in which information is stored for any duration (e.g., for extended time periods, permanently, for brief instances, for temporarily buffering, and / or for caching of the information) . As used herein, the terms “non-transitory computer readable storage device” and “non-transitory machine readable storage device” are defined to include any physical (mechanical, magnetic and / or electrical) hardware to retain information for a time period, but to exclude propagating signals and to exclude transmission media. Examples of non-transitory computer readable storage devices and / or non-transitory machine readable storage devices include random access memory of any type, read only memory of any type, solid state memory, flash memory, optical discs, magnetic disks, disk drives, and / or redundant array of independent disks (RAID) systems. As used herein, the term “device” refers to physical structure such as mechanical and / or electrical equipment, hardware, and / or circuitry that may or may not be configured by computer readable instructions, machine readable instructions, etc., and / or manufactured to execute computer-readable instructions, machine-readable instructions, etc.

[0053] FIG. 4 is a flowchart representative of example machine-readable instructions and / or example operations 400 that may be executed, instantiated, and / or performed by example programmable circuitry to implement the example server communicator circuitry 215 of FIG. 2. The machine-readable instructions and / or the operations 400 of FIG. 4 begin at block 405, at which the local RAG initiator circuitry 220 determines whether the RAG pipeline (e.g., RAG pipeline 103 of FIG. 1) has been deployed on the user device (e.g., user device 205) . If the local RAG initiator circuitry 220 determines that the RAG pipeline has been deployed and / or is available on the user device 205, the local RAG initiator circuitry 220 proceeds to load the RAG pipeline, at block 410. In some examples, the request generator circuitry 320 initiates a request to the server (e.g., server 210) to determine the type of embedding model used as part of the server-based RAG pipeline. Based on the type of embedding model implemented on the server 210, the user device input identifier circuitry 310 determines whether the same embedding model (s) are used on the user device 205 and the server 210, at block 415.

[0054] When the same embedding model (s) are used both locally and externally, the server output identifier circuitry 325 receives embedding data downloaded from the server 210, at block 420, for further implementation on the user device 205 (e.g., as part of the local RAG pipeline) . As such, the embedding model used locally on the user device 205 can benefit from the embedding data associated with the server 210 for performing local assessment of user queries (e.g., using the local RAG initiator circuitry 220 of FIG. 2) . If the user device input identifier circuitry 310 determines that different embedding model (s) are used as part of the RAG pipeline (s) (e.g., on the user device 205 and the server 210) , the user device input identifier circuitry 310 proceeds to monitor for prompt (s) associated with a query (e.g., user query 155) and / or an upload (e.g., document upload 115) , at block 425. When the user device input identifier circuitry 310 identifies a prompt associated with the user query and / or one or more document (s) , the server communicator circuitry 215 proceeds to determine whether to perform local processing of the user query and / or generate a request to the server, at block 430. As described in more detail in connection with FIGS. 5-6, the server communicator circuitry 215 determines the type of processing to perform (e.g., local versus external) based on the type of prompt received at the user device 105 (e.g., a task associated with a low computing requirement versus a task associated with a high computing requirement, etc. ) .

[0055] FIG. 5 is a flowchart representative of example machine-readable instructions and / or example operations 430 that may be executed, instantiated, and / or performed by the example server communicator circuitry 215 of FIG. 2 to perform local processing on a user device 205 or generate a request to the server 210 based on a type of prompt received. The machine-readable instructions and / or the operations 430 of FIG. 5 begin at block 505, at which the user device input identifier circuitry 310 identifies whether the input information is related to user-corrected Question / Answer (Q / A) pairs generated based on user feedback. If the user device input identifier circuitry 310 identifies the Q / Apairs as part of user feedback associated with existing user queries and / or new user queries, the user device input identifier circuitry 310 proceeds to process the Q / Apairs request by prompting the request generator circuitry 320 to provide the Q / Apairs data to the server 210, at block 510, as described in more detail in connection with FIG. 6. If the user device input identifier circuitry 310 determines that the received prompt is associated with a document query, at block 515, the query analyzer circuitry 315 proceeds to determine a compute requirement associated with the query, at block 515.

[0056] As described in connection with FIG. 3, the query analyzer circuitry 315 determines whether the compute requirement associated with the query exceeds a compute requirement threshold, at block 530. For example, when the query analyzer circuitry 315 identifies the prompt as a complex parsing task (e.g., the performance of which will take longer on the user device 205 as compared to the server 210) , the request generator circuitry 320 transmits the query to the server 210 for processing using the server-based RAG pipeline, at block 535. Subsequently, the request generator circuitry 320 receives the server-generated response to the transmitted query (e.g., such that the response can be output locally on the user device 205) . However, if the query analyzer circuitry 315 determines that the query and / or prompt is a task with a low computing requirement (e.g., below the computing requirement threshold needed to transmit the query to the server 210) , the local RAG initiator circuitry 220 proceeds to generate a response to the query and / or prompt using the local RAG pipeline (e.g., RAG pipeline 103 of FIG. 1) , at block 540. In examples disclosed herein, some document (s) may be locally available (e.g., on the user device 205) , while other documents are stored on the server (e.g., server 210) . When the query analyzer circuitry 315 determines that the files are stored on the server 210, the user query can be directly submitted to the server 210 for further processing. However, if the query analyzer circuitry 315 determines that the files are stored locally, the determination of whether to process the files locally or on the server can depend on the type of processing request. In some examples, text-only files can be fully processed locally, while image-to-text or image-generation tasks can be offloaded to the server side if the user device 205 has limited hardware resources (e.g., less than 16GB memory) and / or if a very low latency is desired.

[0057] FIG. 6 is a flowchart representative of example machine-readable instructions and / or example operations 510 that may be executed, instantiated, and / or performed by the example server communicator circuitry 215 of FIG. 2 to process a Question / Answer (Q / A) pairs request. The machine-readable instructions and / or the operations 510 of FIG. 6 begin at block 605, at which the request generator circuitry 320 transmits the Q / Apairs to the server 210 for (1) loading into the server’s vector database and / or (2) fine-tuning a machine learning model engine (e.g., LLM) . As previously described in connection with FIG. 3, the server output identifier circuitry 325 identifies whether the fine-tuned model is ready for downloading from the server 210 after fine-tuning is completed, at block 610. The server output identifier circuitry 325 proceeds to download the fine-tuned model from the server 210 for local use on the user device 205 as part of the local-based RAG pipeline, which also implements a machine learning model engine as part of the local RAG initiator circuitry 220. As such, the accuracy of the local machine learning model engine is improved for local processing of user queries and / or prompts (e.g., associated with a computing requirement that falls below the computing requirement threshold that triggers passing of the user query and / or prompt from the user device 205 to the server 210) .

[0058] FIG. 7 is a block diagram of an example programmable circuitry platform 700 structured to execute and / or instantiate the example machine-readable instructions and / or the example operations of FIGS. 4-6 to implement the example server communicator circuitry 205 of FIG. 2 and / or the local RAG initiator circuitry 220 of FIG. 2. The programmable circuitry platform 700 can be, for example, a server, a personal computer, a workstation, a self-learning machine (e.g., a neural network) , a mobile device (e.g., a cell phone, a smart phone, a tablet such as an iPadTM) , a personal digital assistant (PDA) , an Internet appliance, a DVD player, a CD player, a digital video recorder, a Blu-ray player, a gaming console, a personal video recorder, a set top box, a headset (e.g., an augmented reality (AR) headset, a virtual reality (VR) headset, etc. ) or other wearable device, or any other type of computing and / or electronic device.

[0059] The programmable circuitry platform 700 of the illustrated example includes programmable circuitry 712. The programmable circuitry 712 of the illustrated example is hardware. For example, the programmable circuitry 712 can be implemented by one or more integrated circuits, logic circuits, FPGAs microprocessors, CPUs, GPUs, DSPs, and / or microcontrollers from any desired family or manufacturer. The programmable circuitry 712 may be implemented by one or more semiconductor based (e.g., silicon based) devices. In this example, the processor circuitry 712 implements the local RAG initiator circuitry 220, the user device input identifier circuitry 310, the query analyzer circuitry 315, the request generator circuitry 320, and the server output identifier circuitry 325.

[0060] The programmable circuitry 712 of the illustrated example includes a local memory 713 (e.g., a cache, registers, etc. ) . The programmable circuitry 712 of the illustrated example is in communication with a main memory including a volatile memory 714 and a non-volatile memory 716 by a bus 718. The volatile memory 714 may be implemented by Synchronous Dynamic Random Access Memory (SDRAM) , Dynamic Random Access Memory (DRAM) ,  Dynamic Random Access Memory  , and / or any other type of RAM device. The non-volatile memory 716 may be implemented by flash memory and / or any other desired type of memory device. Access to the main memory 714, 716 of the illustrated example is controlled by a memory controller 717. In some examples, the memory controller 717 may be implemented by one or more integrated circuits, logic circuits, microcontrollers from any desired family or manufacturer, or any other type of circuitry to manage the flow of data going to and from the main memory 714, 716.

[0061] The programmable circuitry platform 700 of the illustrated example also includes interface circuitry 720. The interface circuitry 720 may be implemented by hardware in accordance with any type of interface standard, such as an Ethernet interface, a universal serial bus (USB) interface, a  interface, a near field communication (NFC) interface, a Peripheral Component Interconnect (PCI) interface, and / or a Peripheral Component Interconnect Express (PCIe) interface.

[0062] In the illustrated example, one or more input devices 722 are connected to the interface circuitry 720. The input device (s) 722 permit (s) a user (e.g., a human user, a machine user, etc. ) to enter data and / or commands into the programmable circuitry 712. The input device (s) 722 can be implemented by, for example, an audio sensor, a microphone, a camera (still or video) , a keyboard, a button, a mouse, a touchscreen, a track-pad, a trackball, an isopoint device, and / or a voice recognition system.

[0063] One or more output devices 724 are also connected to the interface circuitry 720 of the illustrated example. The output devices 724 can be implemented, for example, by display devices (e.g., a light emitting diode (LED) , an organic light emitting diode (OLED) , a liquid crystal display (LCD) , a cathode ray tube (CRT) display, an in-place switching (IPS) display, a touchscreen, etc. ) , a tactile output device, a printer, and / or speaker. The interface circuitry 720 of the illustrated example, thus, typically includes a graphics driver card, a graphics driver chip, and / or graphics processor circuitry such as a GPU.

[0064] The interface circuitry 720 of the illustrated example also includes a communication device such as a transmitter, a receiver, a transceiver, a modem, a residential gateway, a wireless access point, and / or a network interface to facilitate exchange of data with external machines (e.g., computing devices of any kind) by a network 726. The communication can be by, for example, an Ethernet connection, a digital subscriber line (DSL) connection, a telephone line connection, a coaxial cable system, a satellite system, a line-of-site wireless system, a cellular telephone system, an optical connection, etc.

[0065] The programmable circuitry platform 700 of the illustrated example also includes one or more mass storage devices 728 to store software and / or data. Examples of such mass storage devices 728 include magnetic storage devices (e.g., floppy disk, drives, HDDs, etc. ) , optical storage devices (e.g., Blu-ray disks, CDs, DVDs, etc. ) , RAID systems, and / or solid-state storage discs or devices such as flash memory devices and / or SSDs.

[0066] The machine executable instructions 732, which may be implemented by the machine readable instructions of FIGS. 4-6, may be stored in the mass storage device 728, in the volatile memory 714, in the non-volatile memory 716, and / or on at least one non-transitory computer readable storage medium such as a CD or DVD which may be removable.

[0067] FIG. 8 is a block diagram of an example implementation of the programmable circuitry 712 of FIG. 7. In this example, the programmable circuitry 712 of FIG. 7 is implemented by a microprocessor 800. For example, the microprocessor 800 may be a general purpose microprocessor (e.g., general purpose microprocessor circuitry) . The microprocessor 800 executes some or all of the machine readable instructions of the flowcharts of FIGS. 4-6 to effectively instantiate the circuitry of FIG. 2 to perform the operations corresponding to those machine readable instructions. In some such examples, the circuitry of FIG. 2 is instantiated by the hardware circuits of the microprocessor 800 in combination with the instructions. For example, the microprocessor 800 may implement multi-core hardware circuitry such as a CPU, a DSP, a GPU, an XPU, etc. Although it may include any number of example cores 802 (e.g., 1 core) , the microprocessor 800 of this example is a multi-core semiconductor device including N cores. The cores 802 of the microprocessor 800 may operate independently or may cooperate to execute machine readable instructions. For example, machine code corresponding to a firmware program, an embedded software program, or a software program may be executed by one of the cores 802 or may be executed by multiple ones of the cores 802 at the same or different times. In some examples, the machine code corresponding to the firmware program, the embedded software program, or the software program is split into threads and executed in parallel by two or more of the cores 802. The software program may correspond to a portion or all of the machine readable instructions and / or operations represented by the flowcharts of FIGS. 4-6.

[0068] The cores 802 may communicate by a first example bus 804. In some examples, the first bus 804 may implement a communication bus to effectuate communication associated with one (s) of the cores 802. For example, the first bus 804 may implement at least one of an Inter-Integrated Circuit (I2C) bus, a Serial Peripheral Interface (SPI) bus, a PCI bus, or a PCIe bus. Additionally or alternatively, the first bus 804 may implement any other type of computing or electrical bus. The cores 802 may obtain data, instructions, and / or signals from one or more external devices by example interface circuitry 806. The cores 802 may output data, instructions, and / or signals to the one or more external devices by the interface circuitry 806. Although the cores 802 of this example include example local memory 820 (e.g., Level 1 (L1) cache that may be split into an L1 data cache and an L1 instruction cache) , the microprocessor 800 also includes example shared memory 810 that may be shared by the cores (e.g., Level 2 (L2_cache) ) for high-speed access to data and / or instructions. Data and / or instructions may be transferred (e.g., shared) by writing to and / or reading from the shared memory 810. The local memory 820 of each of the cores 802 and the shared memory 810 may be part of a hierarchy of storage devices including multiple levels of cache memory and the main memory (e.g., the main memory 714, 716 of FIG. 7) . Typically, higher levels of memory in the hierarchy exhibit lower access time and have smaller storage capacity than lower levels of memory. Changes in the various levels of the cache hierarchy are managed (e.g., coordinated) by a cache coherency policy.

[0069] Each core 802 may be referred to as a CPU, DSP, GPU, etc., or any other type of hardware circuitry. Each core 802 includes control unit circuitry 814, arithmetic and logic (AL) circuitry (sometimes referred to as an ALU) 816, a plurality of registers 818, the L1 cache 820, and a second example bus 822. Other structures may be present. For example, each core 802 may include vector unit circuitry, single instruction multiple data (SIMD) unit circuitry, load / store unit (LSU) circuitry, branch / jump unit circuitry, floating-point unit (FPU) circuitry, etc. The control unit circuitry 814 includes semiconductor-based circuits structured to control (e.g., coordinate) data movement within the corresponding core 802. The AL circuitry 816 includes semiconductor-based circuits structured to perform one or more mathematic and / or logic operations on the data within the corresponding core 802. The AL circuitry 816 of some examples performs integer-based operations. In other examples, the AL circuitry 816 also performs floating-point operations. In yet other examples, the AL circuitry 816 may include first AL circuitry that performs integer-based operations and second AL circuitry that performs floating point operations. In some examples, the AL circuitry 816 may be referred to as an Arithmetic Logic Unit (ALU) .

[0070] The registers 818 are semiconductor-based structures to store data and / or instructions such as results of one or more of the operations performed by the AL circuitry 816 of the corresponding core 802. For example, the registers 818 may include vector register (s) , SIMD register (s) , general purpose register (s) , flag register (s) , segment register (s) , machine specific register (s) , instruction pointer register (s) , control register (s) , debug register (s) , memory management register (s) , machine check register (s) , etc. The registers 818 may be arranged in a bank as shown in FIG. 8. Alternatively, the registers 818 may be organized in any other arrangement, format, or structure including distributed throughout the core 802 to shorten access time. The second bus 822 may be implemented by at least one of an I2C bus, a SPI bus, a PCI bus, or a PCIe bus.

[0071] Each core 802 and / or, more generally, the microprocessor 800 may include additional and / or alternate structures to those shown and described above. For example, one or more clock circuits, one or more power supplies, one or more power gates, one or more cache home agents (CHAs) , one or more converged / common mesh stops (CMSs) , one or more shifters (e.g., barrel shifter (s) ) and / or other circuitry may be present. The microprocessor 800 is a semiconductor device fabricated to include many transistors interconnected to implement the structures described above in one or more integrated circuits (ICs) contained in one or more packages.

[0072] The microprocessor 800 may include and / or cooperate with one or more accelerators (e.g., acceleration circuitry, hardware accelerators, etc. ) . In some examples, accelerators are implemented by logic circuitry to perform certain tasks more quickly and / or efficiently than can be done by a general-purpose processor. Examples of accelerators include ASICs and FPGAs such as those discussed herein. A GPU, DSP and / or other programmable device can also be an accelerator. Accelerators may be on-board the microprocessor 800, in the same chip package as the microprocessor 800 and / or in one or more separate packages from the microprocessor 800.

[0073] FIG. 9 is a block diagram of another example implementation of the programmable circuitry of FIG. 7. In this example, the programmable circuitry 712 is implemented by FPGA circuitry 900. For example, the FPGA circuitry 900 may be implemented by an FPGA. The FPGA circuitry 900 can be used, for example, to perform operations that could otherwise be performed by the example microprocessor 800 of FIG. 8 executing corresponding machine readable instructions. However, once configured, the FPGA circuitry 900 instantiates the operations and / or functions corresponding to the machine readable instructions in hardware and, thus, can often execute the operations / functions faster than they could be performed by a general-purpose microprocessor executing the corresponding software.

[0074] More specifically, in contrast to the microprocessor 800 of FIG. 8 described above (which is a general purpose device that may be programmed to execute some or all of the machine readable instructions represented by the flowcharts of FIGS. 4-6 but whose interconnections and logic circuitry are fixed once fabricated) , the FPGA circuitry 900 of the example of FIG. 9 includes interconnections and logic circuitry that may be configured, structured, programmed, and / or interconnected in different ways after fabrication to instantiate, for example, some or all of the operations / functions corresponding to the machine readable instructions represented by the flowcharts of FIGS. 4-6. In particular, the FPGA 900 may be thought of as an array of logic gates, interconnections, and switches. The switches can be programmed to change how the logic gates are interconnected by the interconnections, effectively forming one or more dedicated logic circuits (unless and until the FPGA circuitry 900 is reprogrammed) . The configured logic circuits enable the logic gates to cooperate in different ways to perform different operations on data received by input circuitry. Those operations may correspond to some or all of the instructions (e.g., the software and / or firmware) represented by the flowcharts of FIGS. 4-6. As such, the FPGA circuitry 900 may be configured and / or structured to effectively instantiate some or all of the operations / functions corresponding to the machine readable instructions of the flowcharts of FIGS. 4-6 as dedicated logic circuits to perform the operations / functions corresponding to those software instructions in a dedicated manner analogous to an ASIC. Therefore, the FPGA circuitry 900 may perform the operations / functions corresponding to the some or all of the machine readable instructions of FIGS. 4-6 faster than the general-purpose microprocessor can execute the same.

[0075] In the example of FIG. 9, the FPGA circuitry 900 is configured and / or structured in response to being programmed (and / or reprogrammed one or more times) based on a binary file. In some examples, the binary file may be compiled and / or generated based on instructions in a hardware description language (HDL) such as Lucid, Very High Speed Integrated Circuits (VHSIC) Hardware Description Language (VHDL) , or Verilog. For example, a user (e.g., a human user, a machine user, etc. ) may write code or a program corresponding to one or more operations / functions in an HDL; the code / program may be translated into a low-level language as needed; and the code / program (e.g., the code / program in the low-level language) may be converted (e.g., by a compiler, a software application, etc. ) into the binary file. In some examples, the FPGA circuitry 900 of FIG. 9 may access and / or load the binary file to cause the FPGA circuitry 900 of FIG. 9 to be configured and / or structured to perform the one or more operations / functions. For example, the binary file may be implemented by a bit stream (e.g., one or more computer-readable bits, one or more machine-readable bits, etc. ) , data (e.g., computer-readable data, machine-readable data, etc. ) , and / or machine-readable instructions accessible to the FPGA circuitry 900 of FIG. 9 to cause configuration and / or structuring of the FPGA circuitry 900 of FIG. 9, or portion (s) thereof.

[0076] In some examples, the binary file is compiled, generated, transformed, and / or otherwise output from a uniform software platform utilized to program FPGAs. For example, the uniform software platform may translate first instructions (e.g., code or a program) that correspond to one or more operations / functions in a high-level language (e.g., C, C++, Python, etc. ) into second instructions that correspond to the one or more operations / functions in an HDL. In some such examples, the binary file is compiled, generated, and / or otherwise output from the uniform software platform based on the second instructions. In some examples, the FPGA circuitry 900 of FIG. 9 may access and / or load the binary file to cause the FPGA circuitry 900 of FIG. 9 to be configured and / or structured to perform the one or more operations / functions. For example, the binary file may be implemented by a bit stream (e.g., one or more computer-readable bits, one or more machine-readable bits, etc. ) , data (e.g., computer-readable data, machine-readable data, etc. ) , and / or machine-readable instructions accessible to the FPGA circuitry 900 of FIG. 9 to cause configuration and / or structuring of the FPGA circuitry 900 of FIG. 9, or portion (s) thereof.

[0077] The FPGA circuitry 900 of FIG. 9, includes example input / output (I / O) circuitry 902 to obtain and / or output data to / from example configuration circuitry 904 and / or external hardware 906. For example, the configuration circuitry 904 may be implemented by interface circuitry that may obtain a binary file, which may be implemented by a bit stream, data, and / or machine-readable instructions, to configure the FPGA circuitry 900, or portion (s) thereof. In some such examples, the configuration circuitry 904 may obtain the binary file from a user, a machine (e.g., hardware circuitry (e.g., programmable or dedicated circuitry) that may implement an Artificial Intelligence / Machine Learning (AI / ML) model to generate the binary file) , etc., and / or any combination (s) thereof) . In some examples, the external hardware 906 may be implemented by external hardware circuitry. For example, the external hardware 906 may be implemented by the microprocessor 800 of FIG. 8.

[0078] The FPGA circuitry 900 also includes an array of example logic gate circuitry 908, a plurality of example configurable interconnections 910, and example storage circuitry 912. The logic gate circuitry 908 and the configurable interconnections 910 are configurable to instantiate one or more operations / functions that may correspond to at least some of the machine readable instructions of FIGS. 4-6 and / or other desired operations. The logic gate circuitry 908 shown in FIG. 9 is fabricated in blocks or groups. Each block includes semiconductor-based electrical structures that may be configured into logic circuits. In some examples, the electrical structures include logic gates (e.g., And gates, Or gates, Nor gates, etc. ) that provide basic building blocks for logic circuits. Electrically controllable switches (e.g., transistors) are present within each of the logic gate circuitry 908 to enable configuration of the electrical structures and / or the logic gates to form circuits to perform desired operations / functions. The logic gate circuitry 908 may include other electrical structures such as look-up tables (LUTs) , registers (e.g., flip-flops or latches) , multiplexers, etc.

[0079] The configurable interconnections 910 of the illustrated example are conductive pathways, traces, vias, or the like that may include electrically controllable switches (e.g., transistors) whose state can be changed by programming (e.g., using an HDL instruction language) to activate or deactivate one or more connections between one or more of the logic gate circuitry 908 to program desired logic circuits.

[0080] The storage circuitry 912 of the illustrated example is structured to store result (s) of the one or more of the operations performed by corresponding logic gates. The storage circuitry 912 may be implemented by registers or the like. In the illustrated example, the storage circuitry 912 is distributed amongst the logic gate circuitry 908 to facilitate access and increase execution speed.

[0081] The example FPGA circuitry 900 of FIG. 9 also includes example dedicated operations circuitry 914. In this example, the dedicated operations circuitry 914 includes special purpose circuitry 916 that may be invoked to implement commonly used functions to avoid the need to program those functions in the field. Examples of such special purpose circuitry 916 include memory (e.g., DRAM) controller circuitry, PCIe controller circuitry, clock circuitry, transceiver circuitry, memory, and multiplier-accumulator circuitry. Other types of special purpose circuitry may be present. In some examples, the FPGA circuitry 900 may also include example general purpose programmable circuitry 918 such as an example CPU 920 and / or an example DSP 922. Other general purpose programmable circuitry 918 may additionally or alternatively be present such as a GPU, an XPU, etc., that can be programmed to perform other operations.

[0082] Although FIGS. 8 and 9 illustrate two example implementations of the programmable circuitry 712 of FIG. 7, many other approaches are contemplated. For example, FPGA circuitry may include an on-board CPU, such as one or more of the example CPU 920 of FIG. 9. Therefore, the programmable circuitry 712 of FIG. 7 may additionally be implemented by combining at least the example microprocessor 800 of FIG. 8 and the example FPGA circuitry 900 of FIG. 9. In some such hybrid examples, one or more cores 902 of FIG. 9 may execute a first portion of the machine readable instructions represented by the flowchart (s) of FIGS. 4-6 to perform first operation (s)  / function (s) , the FPGA circuitry 900 of FIG. 9 may be configured and / or structured to perform second operation (s)  / function (s) corresponding to a second portion of the machine readable instructions represented by the flowcharts of FIGS. 4-6, and / or an ASIC may be configured and / or structured to perform third operation (s)  / function (s) corresponding to a third portion of the machine readable instructions represented by the flowcharts of FIGS. 4-6.

[0083] It should be understood that some or all of the circuitry of FIG. 2 may, thus, be instantiated at the same or different times. For example, same and / or different portion (s) of the microprocessor 800 of FIG. 8 may be programmed to execute portion (s) of machine-readable instructions at the same and / or different times. In some examples, same and / or different portion (s) of the FPGA circuitry 900 of FIG. 9 may be configured and / or structured to perform operations / functions corresponding to portion (s) of machine-readable instructions at the same and / or different times.

[0084] In some examples, some or all of the circuitry of FIG. 2 may be instantiated, for example, in one or more threads executing concurrently and / or in series. For example, the microprocessor 800 of FIG. 8 may execute machine readable instructions in one or more threads executing concurrently and / or in series. In some examples, the FPGA circuitry 900 of FIG. 9 may be configured and / or structured to carry out operations / functions concurrently and / or in series. Moreover, in some examples, some or all of the circuitry of FIG. 2 may be implemented within one or more virtual machines and / or containers executing on the microprocessor 800 of FIG. 8.

[0085] In some examples, the programmable circuitry 712 of FIG. 7 may be in one or more packages. For example, the microprocessor 800 of FIG. 8 and / or the FPGA circuitry 900 of FIG. 9 may be in one or more packages. In some examples, an XPU may be implemented by the programmable circuitry 712 of FIG. 7 which may be in one or more packages. For example, the XPU may include a CPU (e.g., the microprocessor 800 of FIG. 8, the CPU 920 of FIG. 9, etc. ) in one package, a DSP (e.g., the DSP 922 of FIG. 9) in another package, a GPU in yet another package, and an FPGA (e.g., the FPGA circuitry 900 of FIG. 9) in still yet another package.

[0086] A block diagram illustrating an example software distribution platform 1005 to distribute software such as the example machine readable instructions 732 of FIG. 7 to other hardware devices (e.g., hardware devices owned and / or operated by third parties from the owner and / or operator of the software distribution platform) is illustrated in FIG. 10. The example software distribution platform 1005 may be implemented by any computer server, data facility, cloud service, etc., capable of storing and transmitting software to other computing devices. The third parties may be customers of the entity owning and / or operating the software distribution platform 1005. For example, the entity that owns and / or operates the software distribution platform 1005 may be a developer, a seller, and / or a licensor of software such as the example machine readable instructions 732 of FIG. 7. The third parties may be consumers, users, retailers, OEMs, etc., who purchase and / or license the software for use and / or re-sale and / or sub-licensing. In the illustrated example, the software distribution platform 1005 includes one or more servers and one or more storage devices. The storage devices store the machine readable instructions 732, which may correspond to the example machine readable instructions of FIGS. 4-6, as described above. The one or more servers of the example software distribution platform 1005 are in communication with an example network 1010, which may correspond to any one or more of the Internet and / or any of the example networks described above. In some examples, the one or more servers are responsive to requests to transmit the software to a requesting party as part of a commercial transaction. Payment for the delivery, sale, and / or license of the software may be handled by the one or more servers of the software distribution platform and / or by a third party payment entity. The servers enable purchasers and / or licensors to download the machine readable instructions 732 from the software distribution platform 1005. For example, the software, which may correspond to the example machine readable instructions of FIGS. 4-6, may be downloaded to the example programmable circuitry platform 700, which is to execute the machine readable instructions 732 to implement the server communicator circuitry 205 of FIG. 2 and / or the local RAG initiator circuitry 220 of FIG. 2. In some examples, one or more servers of the software distribution platform 1005 periodically offer, transmit, and / or force updates to the software (e.g., the example machine readable instructions 732 of FIG. 7) to ensure improvements, patches, updates, etc., are distributed and applied to the software at the end user devices. Although referred to as software above, the distributed “software” could alternatively be firmware.

[0087] “Including” and “comprising” (and all forms and tenses thereof) are used herein to be open ended terms. Thus, whenever a claim employs any form of “include” or “comprise” (e.g., comprises, includes, comprising, including, having, etc. ) as a preamble or within a claim recitation of any kind, it is to be understood that additional elements, terms, etc., may be present without falling outside the scope of the corresponding claim or recitation. As used herein, when the phrase “at least” is used as the transition term in, for example, a preamble of a claim, it is open-ended in the same manner as the term “comprising” and “including” are open ended. The term “and / or” when used, for example, in a form such as A, B, and / or C refers to any combination or subset of A, B, C such as (1) A alone, (2) B alone, (3) C alone, (4) A with B, (5) A with C, (6) B with C, or (7) A with B and with C. As used herein in the context of describing structures, components, items, objects and / or things, the phrase “at least one of A and B” is intended to refer to implementations including any of (1) at least one A, (2) at least one B, or (3) at least one A and at least one B. Similarly, as used herein in the context of describing structures, components, items, objects and / or things, the phrase “at least one of A or B” is intended to refer to implementations including any of (1) at least one A, (2) at least one B, or (3) at least one A and at least one B. As used herein in the context of describing the performance or execution of processes, instructions, actions, activities, etc., the phrase “at least one of A and B” is intended to refer to implementations including any of (1) at least one A, (2) at least one B, or (3) at least one A and at least one B. Similarly, as used herein in the context of describing the performance or execution of processes, instructions, actions, activities, etc., the phrase “at least one of A or B” is intended to refer to implementations including any of (1) at least one A, (2) at least one B, or (3) at least one A and at least one B.

[0088] As used herein, singular references (e.g., “a” , “an” , “first” , “second” , etc. ) do not exclude a plurality. The term “a” or “an” object, as used herein, refers to one or more of that object. The terms “a” (or “an” ) , “one or more” , and “at least one” are used interchangeably herein. Furthermore, although individually listed, a plurality of means, elements, or actions may be implemented by, e.g., the same entity or object. Additionally, although individual features may be included in different examples or claims, these may possibly be combined, and the inclusion in different examples or claims does not imply that a combination of features is not feasible and / or advantageous.

[0089] As used herein, the phrase “in communication, ” including variations thereof, encompasses direct communication and / or indirect communication through one or more intermediary components, and does not require direct physical (e.g., wired) communication and / or constant communication, but rather additionally includes selective communication at periodic intervals, scheduled intervals, aperiodic intervals, and / or one-time events.

[0090] As used herein, “programmable circuitry” is defined to include (i) one or more special purpose electrical circuits (e.g., an application specific circuit (ASIC) ) structured to perform specific operation (s) and including one or more semiconductor-based logic devices (e.g., electrical hardware implemented by one or more transistors) , and / or (ii) one or more general purpose semiconductor-based electrical circuits programmable with instructions to perform specific functions (s) and / or operation (s) and including one or more semiconductor-based logic devices (e.g., electrical hardware implemented by one or more transistors) . Examples of programmable circuitry include programmable microprocessors such as Central Processor Units (CPUs) that may execute first instructions to perform one or more operations and / or functions, Field Programmable Gate Arrays (FPGAs) that may be programmed with second instructions to cause configuration and / or structuring of the FPGAs to instantiate one or more operations and / or functions corresponding to the first instructions, Graphics Processor Units (GPUs) that may execute first instructions to perform one or more operations and / or functions, Digital Signal Processors (DSPs) that may execute first instructions to perform one or more operations and / or functions, XPUs, Network Processing Units (NPUs) one or more microcontrollers that may execute first instructions to perform one or more operations and / or functions and / or integrated circuits such as Application Specific Integrated Circuits (ASICs) . For example, an XPU may be implemented by a heterogeneous computing system including multiple types of programmable circuitry (e.g., one or more FPGAs, one or more CPUs, one or more GPUs, one or more NPUs, one or more DSPs, etc., and / or any combination (s) thereof) , and orchestration technology (e.g., application programming interface (s) (API (s) ) that may assign computing task (s) to whichever one (s) of the multiple types of programmable circuitry is / are suited and available to perform the computing task (s) .

[0091] As used herein integrated circuit / circuitry is defined as one or more semiconductor packages containing one or more circuit elements such as transistors, capacitors, inductors, resistors, current paths, diodes, etc. For example, an integrated circuit may be implemented as one or more of an ASIC, an FPGA, a chip, a microchip, programmable circuitry, a semiconductor substrate coupling multiple circuit elements, a system on chip (SoC) , etc.

[0092] From the foregoing, it will be appreciated that example systems, methods, apparatus, and articles of manufacture disclosed herein optimize the utilization of existing enterprise-grade resources for improving the accuracy of GenAI. For example, methods and apparatus disclosed herein improve AI assistant capabilities across diverse hardware configurations, ensuring seamless document management and / or query resolution through an interconnected system of local device (e.g., AI PC) and server-side resources. For example, a RAG-based AI assistant can be deployed on both an AI PC and an enterprise server, allowing for efficient querying regardless of where the documents are located (e.g., locally or externally) . Methods and apparatus disclosed herein further allow for computationally intensive tasks (e.g., complex parsing tasks, etc. ) to be performed on the server instead of on the local device (e.g., based on a compute requirement threshold) , reducing the amount of time for task completion. Thus, examples disclosed herein result in improvements to the operation of a machine.

[0093] Example methods, apparatus, systems, and articles of manufacture for end-to-end enterprise-based Generative Artificial Intelligence (GenAI) are disclosed herein. Further examples and combinations thereof include the following:

[0094] Example 1 includes an apparatus, comprising interface circuitry, machine-readable instructions, and at least one processor circuit to be programmed by the machine-readable instructions to access a prompt received at a user device, the prompt associated with a document, determine a compute requirement associated with the prompt, transmit the document to a server when the compute requirement exceeds a threshold, and receive an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.

[0095] Example 2 includes the apparatus of example 1, wherein one or more of the at least one processor circuit is to process the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.

[0096] Example 3 includes the apparatus of example 1 and / or example 2, wherein, when the prompt is a document query associated with a complex parsing task, one or more of the at least one processor circuit is to transmit the document query to the server.

[0097] Example 4 includes the apparatus of any one or more of examples 1-3, wherein one or more of the at least one processor circuit is to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.

[0098] Example 5 includes the apparatus of any one or more of examples 1-4, wherein, when the prompt includes user feedback on a query, one or more of the at least one processor circuit is to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.

[0099] Example 6 includes the apparatus of any one or more of examples 1-5, wherein one or more of the at least one processor circuit is to download the fine-tuned model from the server.

[0100] Example 7 includes the apparatus of any one or more of examples 1-6, wherein, when an embedding model on the user device matches the embedding model on the server, one or more of the at least one processor circuit is to download embedding data from the server.

[0101] Example 8 includes at least one non-transitory machine-readable medium comprising machine-readable instructions to cause at least one processor circuit to at least access a prompt received at a user device, the prompt associated with a document, determine a compute requirement associated with the prompt, transmit the document to a server when the compute requirement exceeds a threshold, and receive an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.

[0102] Example 9 includes the at least one non-transitory machine-readable medium of example 8, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to process the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.

[0103] Example 10 includes the at least one non-transitory machine-readable medium of example 8 and / or example 9, wherein, when the prompt is a document query associated with a complex parsing task, the machine-readable instructions are to cause one or more of the at least one processor circuit to transmit the document query to the server.

[0104] Example 11 includes the at least one non-transitory machine-readable medium of any one or more of examples 8-10, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.

[0105] Example 12 includes the at least one non-transitory machine-readable medium of any one or more of examples 8-11, wherein, when the prompt includes user feedback on a query, the machine-readable instructions are to cause one or more of the at least one processor circuit to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.

[0106] Example 13 includes the at least one non-transitory machine-readable medium of any one or more of examples 8-12, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to download the fine-tuned model from the server.

[0107] Example 14 includes the at least one non-transitory machine-readable medium of any one or more of examples 8-13, wherein, when an embedding model on the user device matches the embedding model on the server, the machine-readable instructions are to cause one or more of the at least one processor circuit to download embedding data from the server.

[0108] Example 15 includes an apparatus, comprising means for accessing a prompt received at a user device, the prompt associated with a document, means for assessing a query to determine a compute requirement associated with the prompt, means for generating a server request by transmitting the document to a server when the compute requirement exceeds a threshold, and means for receiving an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.

[0109] Example 16 includes the apparatus of example 15, further including means for vectorizing to process the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.

[0110] Example 17 includes the apparatus of example 15 and / or example 16, wherein, when the prompt is a document query associated with a complex parsing task, the means for generating the server request is to transmit the document query to the server.

[0111] Example 18 includes the apparatus of any one or more of examples 15-17, wherein the means for receiving the output is to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.

[0112] Example 19 includes the apparatus of any one or more of examples 15-18, wherein when the prompt includes user feedback on a query, the means for generating the server request is to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.

[0113] Example 20 includes the apparatus of any one or more of examples 15-19, wherein the means for receiving the output is to download the fine-tuned model from the server.

[0114] The following claims are hereby incorporated into this Detailed Description by this reference. Although certain example systems, methods, apparatus, and articles of manufacture have been disclosed herein, the scope of coverage of this patent is not limited thereto. On the contrary, this patent covers all systems, methods, apparatus, and articles of manufacture fairly falling within the scope of the claims of this patent.

Claims

1.An apparatus, comprising:interface circuitry;machine-readable instructions; andat least one processor circuit to be programmed by the machine-readable instructions to:access a prompt received at a user device, the prompt associated with a document;determine a compute requirement associated with the prompt;transmit the document to a server when the compute requirement exceeds a threshold; andreceive an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.2.The apparatus of claim 1, wherein one or more of the at least one processor circuit is to vectorize the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.3.The apparatus of claim 1, wherein, when the prompt is a document query associated with a complex parsing task, one or more of the at least one processor circuit is to transmit the document query to the server.4.The apparatus of claim 3, wherein one or more of the at least one processor circuit is to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.5.The apparatus of claim 1, wherein, when the prompt includes user feedback on a query, one or more of the at least one processor circuit is to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.6.The apparatus of claim 5, wherein one or more of the at least one processor circuit is to download the fine-tuned model from the server.7.The apparatus of claim 1, wherein, when an embedding model on the user device matches the embedding model on the server, one or more of the at least one processor circuit is to download embedding data from the server.8.At least one non-transitory machine-readable medium comprising machine-readable instructions to cause at least one processor circuit to at least:access a prompt received at a user device, the prompt associated with a document;determine a compute requirement associated with the prompt;transmit the document to a server when the compute requirement exceeds a threshold; andreceive an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.9.The at least one non-transitory machine-readable medium of claim 8, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to vectorize the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.10.The at least one non-transitory machine-readable medium of claim 8, wherein, when the prompt is a document query associated with a complex parsing task, the machine-readable instructions are to cause one or more of the at least one processor circuit to transmit the document query to the server.11.The at least one non-transitory machine-readable medium of claim 10, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.12.The at least one non-transitory machine-readable medium of claim 8, wherein, when the prompt includes user feedback on a query, the machine-readable instructions are to cause one or more of the at least one processor circuit to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.13.The at least one non-transitory machine-readable medium of claim 12, wherein the machine-readable instructions are to cause one or more of the at least one processor circuit to download the fine-tuned model from the server.14.The at least one non-transitory machine-readable medium of claim 8, wherein, when an embedding model on the user device matches the embedding model on the server, the machine-readable instructions are to cause one or more of the at least one processor circuit to download embedding data from the server.15.An apparatus, comprising:means for accessing a prompt received at a user device, the prompt associated with a document;means for assessing a query to determine a compute requirement associated with the prompt;means for generating a server request by transmitting the document to a server when the compute requirement exceeds a threshold; andmeans for receiving an output from the server, the output corresponding to a large language model (LLM) output from a retrieval augmented generation (RAG) pipeline located on the server.16.The apparatus of claim 15, further including means for vectorizing to vectorize the document by implementing a RAG pipeline located on the user device when the compute requirement is below the threshold.17.The apparatus of claim 15, wherein, when the prompt is a document query associated with a complex parsing task, the means for generating the server request is to transmit the document query to the server.18.The apparatus of claim 17, wherein the means for receiving the output is to retrieve a parsed document from the server, the parsed document generated at the server based on the complex parsing task.19.The apparatus of claim 15, wherein when the prompt includes user feedback on a query, the means for generating the server request is to transmit the user feedback to the server for (1) loading into a vector database of the server or (2) performing fine-tuning of the LLM to generate a fine-tuned model.20.The apparatus of claim 19, wherein the means for receiving the output is to download the fine-tuned model from the server.

Images