Systems and methods for implementing a knowledge sharing engine based on speech signal processing during a user interface session

Abstract

Systems and methods for implementing a knowledge sharing engine based on speech signal processing during a user interface session. For example, in response to detecting a first short phrase, the system can determine whether the first short phrase corresponds to one or more tagged short phrases. In response to determining that the first short phrase does not correspond to one or more tagged short phrases, the system can determine a first domain corresponding to one or more users of a plurality of users. The system can retrieve a first domain profile corresponding to the first domain. The system can generate a first feature input corresponding to the first short phrase and the first domain profile.

Description

Background Technology

[0001] Knowledge sharing within enterprises is often challenging due to a combination of organizational, cultural, and technological factors. Employees may be confined to their departments, lacking the time or incentive to record and share insights, or fear losing a competitive edge by leaking valuable expertise. Furthermore, the sheer volume and fragmentation of information make it difficult to effectively capture, organize, and disseminate knowledge. The rise of video conferencing, while improving remote collaboration, has inadvertently made knowledge sharing even more challenging. Meetings held via video calls are often not recorded, transcribed, or easily searchable, meaning key information is often locked in the conversation and lost once the meeting ends. Even when records are available, they are time-consuming to review and rarely indexed in a way that makes them later reviewable or actionable. Traditional video conferencing tools contribute to this problem by focusing primarily on real-time communication rather than knowledge capture and retrieval. They often lack integrated tools for note-taking, automatic transcription, tagging, or linking discussion points to existing documents or projects, resulting in a disconnect between the conversation and the enterprise's broader knowledge base. Summary of the Invention

[0002] Furthermore, even with enhancements to knowledge-sharing tools such as note-taking, automatic transcription, tagging, and linking, these improvements fail to address the core issue: the lack of contextual understanding and domain-specific insights internalized in the minds of participants. Transcriptions and notes can capture what is said, but not necessarily what it means, nor the differentiated reasoning, assumptions, or unspoken knowledge that underpins the conversation. These tools often reduce rich, complex discussions to superficial summaries lacking the depth required for true knowledge dissemination. Without broader context—such as the specific problem being solved, the history behind certain decisions, or tacit knowledge derived from personal experience—the recorded content remains incomplete and difficult to apply meaningfully to others. Thus, even well-documented meetings may fail to convey the true "know-how" for driving innovation and problem-solving within an organization. True knowledge sharing requires more than just capturing words; it requires mechanisms for interpreting and contextualizing those words within their relevant domains.

[0003] Therefore, this paper describes systems and methods for implementing a knowledge-sharing engine based on speech signal processing during user interface sessions. As an example, this paper describes systems and methods for mitigating the lack of contextual understanding in knowledge-sharing tools. As an example, unlike traditional speech-to-text tools, the system supplements detected phrases with additional domain knowledge before generating feature input ingested by one or more models.

[0004] Supplementing detected phrases with domain knowledge before generalization is technically superior because it allows the system to interpret language in a context-aware, precise, and semantically rich manner. Unlike traditional speech-to-text tools that transcribe words in isolation, systems integrating domain knowledge can not only identify what is said but also its meaning within a specific professional or organizational context. By enriching detected phrases with relevant terms, relationships, and concepts before processing them downstream, the system creates more informative and structured feature inputs. This contextualization improves model performance by reducing ambiguity, enhancing relevance, and achieving more accurate generalizations and classifications. It also leads to more efficient processing because the model can focus on higher-level interpretations rather than expending computational effort parsing meaning from unstructured text. Ultimately, this approach enables more actionable outputs, such as summaries highlighting key decisions, risks, or insights—rather than general overviews—supporting better knowledge retention and decision-making across the enterprise.

[0005] In some aspects, systems and methods for implementing a knowledge-sharing engine based on speech signal processing during a user interface session are described. For example, the system may receive a first audio input during a first user interface session among multiple users. The system may generate a first text string based on the first audio input. The system may parse the first text string to detect a first short phrase. In response to detecting the first short phrase, the system may determine whether the first short phrase corresponds to one or more tagged short phrases. In response to determining that the first short phrase does not correspond to one or more tagged short phrases, the system may determine a first domain corresponding to one or more of the multiple users. The system may retrieve a first domain profile corresponding to the first domain. The system may generate a first feature input corresponding to the first short phrase and the first domain profile. The system may input the first feature input into a first model to determine a first tagged short phrase of the first short phrase. The system may generate a first summary corresponding to the first user interface session based on the first tagged short phrase. The system may generate a first summary for display on the user interface.

[0006] Various other aspects, features, and advantages of the invention will become apparent from the detailed description and accompanying drawings. It should also be understood that the foregoing general description and the following detailed description are exemplary and do not limit the scope of the invention. As used in the specification and claims, the singular forms “a,” “an,” and “the” include plural indicators unless the context clearly specifies otherwise. Additionally, as used in the specification and claims, the term “or” means “and / or” unless the context clearly specifies otherwise. Furthermore, as used in the specification, “a portion” means a part or all (i.e., the entire portion) of a given item (e.g., data) unless the context clearly specifies otherwise. Attached Figure Description

[0007] Figure 1 An exemplary diagram of a user interface session according to one or more embodiments is shown.

[0008] Figure 2A An exemplary diagram of a model for a knowledge-sharing engine according to one or more embodiments is shown.

[0009] Figure 2B An exemplary diagram of a model for overview is shown according to one or more embodiments.

[0010] Figure 3 Exemplary components of a system for implementing knowledge sharing according to one or more embodiments are shown.

[0011] Figure 4 A flowchart illustrating the steps involved in implementing knowledge sharing according to one or more embodiments is shown. Detailed Implementation

[0012] In the following description, numerous specific details are set forth for purposes of explanation in order to provide a thorough understanding of embodiments of the invention. However, those skilled in the art will understand that embodiments of the invention can be practiced without these specific details or with equivalent arrangements. In other instances, well-known structures and devices are illustrated in block diagram form to avoid unnecessarily obscuring embodiments of the invention.

[0013] Figure 1 An exemplary diagram of a user interface session according to one or more embodiments is shown. For example, Figure 1 User interface 100 is illustrated. As described herein, a user interface can include visual and interactive components of a software application, system, or device that enable users to communicate and engage with its underlying functionality. It includes all elements that the user sees and interacts with—such as buttons, menus, icons, text fields, and visual layouts—as well as input methods such as touch, mouse clicks, keystrokes, or voice commands. The primary purpose of a user interface is to translate user intent into system actions and present system responses in a clear and accessible manner. A well-designed user interface focuses on usability, responsiveness, and clarity, ensuring that users can navigate the system efficiently and perform tasks with minimal friction or clutter. In more advanced systems, the user interface may also include personalized content, contextual recommendations, and adaptive features that adjust based on user behavior.

[0014] User interface 100 can represent a current user interface session between multiple users. As shown, user interface 102 can generate content (e.g., transcripts, summaries, and / or other content corresponding to the user interface session). To generate content, the system can detect short phrases (e.g., acronym 104). For example, user interface 100 can represent a current user interface session between multiple users by acting as a central point for interactions between participants through real-time exchanges of messages, video, audio, or shared content. This interface provides each user with a synchronized view of the session, including communication channels, visual indicators of participant activity, and tools for collaboration. For example, user interface 102, as part of interface 100, can generate content reflecting the ongoing conversation or activity, such as a live transcript, session summary, or contextual recommendations. To generate this content, the system monitors input from all participants—such as spoken conversations, typed chat, or shared documents—and processes them using natural language processing and contextual analysis. During this process, the system can detect short phrases such as acronym 104 and interpret them within the context of the domain or topic under discussion. Identifying and correctly interpreting these short phrases allows the system to enhance the generated content, ensuring it is accurate, meaningful, and appropriate for the shared context of the conversation. This enables the user interface to provide value-added insights, improve collaboration, and maintain a coherent record of the conversation.

[0015] User interface 100 can display and / or receive various types of content. For example, the types of content that can be generated for display in the user interface include a wide range of information designed to notify, guide, or prompt user interaction. This content can be informational, such as transaction summaries, notifications, system alerts, or event reports presenting real-time data and system feedback. It can also be interactive, including buttons, drop-down menus, search bars, sliders, and forms that allow users to input or adjust data. Visual elements such as charts, graphs, tables, icons, and status indicators are often used to help users quickly interpret complex information or monitor trends. Furthermore, the user interface can generate personalized content, such as recommendations, alerts tailored to user behavior, or adaptive layouts adjusted based on user preferences or device type. Guidance content, such as tooltips, onboarding guides, or error messages, is also crucial for guiding users to complete tasks or resolve problems.

[0016] In some embodiments, content may include text strings. For example, a text string can be a sequence of characters used to represent textual information in a digital system. It consists of individual elements such as letters, numbers, symbols, and spaces, all arranged in a specific order to convey meaning. A text string can be as simple as a single word or as complex as a complete sentence, paragraph, or code snippet. In programming and data structures, text strings are often enclosed in quotation marks and treated as a data type that can be manipulated, stored, or displayed. In user interfaces, text strings can appear in various forms, such as labels on buttons, titles, tooltips, alerts, messages, form field values, and dynamically generated content. They provide users with necessary context, guide interactions, deliver feedback, or present information. For example, a user interface might display the text string "Payment successful" in a confirmation dialog box or a transaction description like "Monthly subscription - $9.99" in a financial dashboard. Text strings are central to clear communication in a user interface, ensuring users understand the system's output and available operations.

[0017] In some embodiments, the text string may be based on audio input. For example, audio input can be a sound-based signal captured by a device such as a microphone and processed by the system to perform a specific function—typically involving speech recognition, sound analysis, or voice commands. It consists of acoustic waveforms that are converted into digital signals and are typically represented as audio files or real-time data streams. These inputs can include spoken words, background noise, music, or any other form of audible sound. In the user interface, audio input can appear in several ways, often accompanied by visual indicators confirming that the system is actively listening or recording. For example, the UI may display a microphone icon that lights up or animates when audio input is being received, or show a live transcript of spoken words in real time. Some interfaces may also include voice command prompts or options for playing back and editing recorded audio. Audio input enhances user interaction by enabling hands-free control, accessibility features, and natural language communication, making it an essential component of voice-enabled applications and systems.

[0018] In some embodiments, a user interface can correspond to a user interface session. For example, a user interface session can be a continuous interaction between a user and a software application or system that begins when the user accesses the interface and ends when they log out, close the application, or the session times out due to inactivity. It consists of all activities, inputs, and outputs that occur during that time frame, including user actions (such as clicks, form submissions, or voice commands), displayed content, and system responses. Each session can be distinguished from another session by a unique session identifier, which is typically assigned by the system at the start of the session. This ID is used to track and isolate the user's specific interaction context, allowing the system to manage personalized content, maintain state (e.g., the page the user is on or which filters they have applied), and ensure secure data processing. Data unique to a user interface session can include session IDs, timestamps, user preferences, temporary selections, authentication tokens, and activity logs. This session-specific data enables the system to provide a seamless and personalized user experience while also supporting analytics, debugging, and security monitoring.

[0019] In some embodiments, a group chat or group video session can be considered a user interface session because it represents different periods of active interaction between a user and a communication platform through its interface. During such a session, participants engage in real-time messaging, voice, or video communication, all facilitated by visible and interactive UI elements such as chat windows, participant lists, mute buttons, video feeds, and shared content panels. A session begins when a user joins a group chat or video call and ends when they leave or the session terminates. It is considered a single interface session because all actions (such as sending messages, adjusting audio / video settings, or responding to notifications) are related to the user's continuous interaction with the interface. Each group session can be distinguished by a unique session ID or meeting link and user-specific session data such as join time, message history, device settings, or speaking activity can be recorded to personalize the experience, maintain status, and support features such as real-time collaboration, adjustment, and analytics.

[0020] In some embodiments, the system can detect short phrases (e.g., abbreviations, acronyms, and / or other context-carrying characters). For example, short phrases—such as abbreviations, acronyms, or other context-carrying strings—are compressed forms of one or more words that convey meaning using fewer characters. These phrases are often used to improve efficiency, particularly in technical, professional, or informal communication. Examples include “VPN” for Virtual Private Networks, “ETA” for Estimating Time of Arrival, or symbols such as “@” for indicating a user or location. Each short phrase can be distinguished from another short phrase based on its specific character sequence and the context in which it appears. Detection of short phrases typically involves Natural Language Processing (NLP) or pattern matching techniques. The system can accurately identify and interpret these phrases using dictionaries of known acronyms and acronyms, regular expressions, or machine learning models trained on contextual data. Furthermore, the surrounding words and sentence structure help to disambiguate meaning by evaluating how the phrase is used in context—for example, distinguishing “AI” from Artificial Intelligence versus Adobe Illustrator.

[0021] In some embodiments, the system can determine the domain used to interpret short phrases. For example, a domain can refer to a specific area of ​​knowledge, function, or control within a system or organization, and it can take various forms depending on the context. For instance, in an enterprise setting, a domain can represent user roles such as “finance,” “engineering,” or “customer support,” each with its own terminology and workflows. In computing, a domain can refer to a networked environment managed by a centralized directory service, such as a Windows Active Directory domain, which defines user access and resource permissions. Domains can also represent broader professional fields, such as legal, medical, or cybersecurity fields. When interpreting short phrases (such as acronyms or abbreviations), domains provide the basic context that helps determine the correct meaning. For example, the acronym “RAM” in the hardware field refers to Random Access Memory, while in a business role related to customer management, it might mean Relationship Account Manager. By associating phrases with appropriate domains, the system can eliminate ambiguity in meaning and provide more accurate interpretations, thereby improving the reliability of natural language processing, user interfaces, and recommendation systems.

[0022] In some embodiments, the system may determine a domain profile corresponding to a domain. For example, a domain profile may be a collection of characteristics, attributes, or metadata that collectively define operational contexts, behavioral patterns, and language patterns associated with a particular domain. It serves as a structured representation of typical or expected content within that domain, enabling the system to make more accurate interpretations and decisions. For instance, in a cybersecurity domain, a domain profile may include characteristics such as terminology (e.g., “DDoS,” “phishing”), typical data types (IP addresses, log files), threat patterns, and user roles (e.g., analyst or administrator). In the medical field, a profile may include medical terminology, common acronyms (e.g., “BP” for blood pressure), document formats (e.g., clinical records), and roles such as physician, nurse, or patient. In the customer service field, a profile may contain dialogue patterns, complaint categories, mood cues, and terms such as “ticket” or “resolution.”

[0023] The system can determine domain profiles corresponding to domains by analyzing available data sources, user behavior, and interaction history. This may involve identifying keywords, monitoring activity patterns, and inferring domains using user roles or access permissions. Machine learning models, clustering techniques, or rule-based logic can also be used to classify data and build or retrieve matching domain profiles. Once established, domain profiles help guide language interpretation, short phrase parsing, user intent recognition, and system recommendations by anchoring them within appropriate contextual frameworks.

[0024] In some embodiments, the system can generate content corresponding to a user interface session (e.g., summaries, recommendations, etc.). For example, the system can generate content, such as summaries, recommendations, or alerts, corresponding to a user interface session by continuously monitoring and analyzing the user's actions, inputs, and contextual data throughout the session. As the session progresses, the system captures relevant interaction details, such as selected options, viewed content, entered text, navigation paths, or verbal commands. This data is then processed using natural language processing (NLP), machine learning models, or rule-based logic to extract meaningful insights. For example, if a user interacts with multiple financial transactions during a session, the system can generate summaries highlighting spending patterns or flagging unusual activity. If a user is participating in a group video session about cybersecurity, the system can generate recommendations based on the topics discussed or detected concerns. The generated content is tailored to the session's domain, the user's role, and specific context to ensure relevance and clarity. Finally, the content is formatted for display and integrated into the user interface, appearing either in real-time or at the end of the session to enhance user understanding, simplify decision-making, or prompt further action.

[0025] In some embodiments, the system may receive a first audio input during a first user interface session between multiple users. The system may generate a first text string based on applying a first speech signal processing algorithm to the first audio input. The system may parse the first text string to detect first language acronyms. For example, the system may detect language acronyms by first processing the audio input received during the user interface session. For example, when the system receives the first audio input during a session between multiple users, it begins by applying a first speech signal processing algorithm—such as Automatic Speech Recognition (ASR)—to convert spoken words into a first text string. This conversion captures the speech content of the conversation and transcribes it into readable text. Once the text string is generated, the system parses it using natural language processing techniques to identify language patterns indicating acronyms. This involves scanning sequences of capital letters, abbreviations, or known acronyms within a predefined or domain-specific dictionary. Additionally, the system may use contextual clues from surrounding words to help confirm that the detected terms are indeed language acronyms and not coincidental word sequences. For example, if the transcribed sentence contains "We will use the API for integration," the system will recognize "API" as a possible acronym for "Application Programming Interface" based on its format and context. This detection enables further processing, such as expanding the acronym, linking it to relevant domain knowledge, or including it in the transcript or summary of the session.

[0026] Figure 2A An exemplary diagram of a model for a knowledge-sharing engine according to one or more embodiments is shown. For example, Figure 2A Architecture 200 for a model used in a knowledge-sharing engine is shown. Architecture 200 illustrates a multi-stage pipeline for developing domain-specific AI models focused on meeting summaries and question-and-answer capabilities. At point 210, the process can begin within an internal enterprise database, where various raw data sources are collected. One input could be meeting audio, which is processed using a speech-to-text conversion tool to generate transcribed transcripts. These transcripts form the core text input for downstream processing. In addition to audio-based transcripts, the system can ingest various other enterprise documents, such as meeting records with metadata, API-accessible company wikis that may include internal policies or technical documents, and scraped internal web pages that may contain product documentation, HR FAQs, or support manuals. All these text resources can be filtered to exclude personally identifiable information (PII) to ensure data privacy and comply with the system's internal data governance policies. The sanitized content can then be stored in a vector database that supports Retrieval Augmentation Generation (RAG).

[0027] At point 220 (e.g., Model Training Phase I), the preprocessing pipeline enhances the raw transcript by identifying meeting type (e.g., sprint planning, client onboarding, security review) and participant roles (e.g., presenter, recorder, project manager, engineer). These annotations provide structural context that helps the model better understand who said what and in what setting (important for distinguishing action items, decisions, and general discussions). This enriched data is then passed to point 230 (e.g., Model Training Phase II), where the system generates training data. Using a first language model (LLM1), the system can automatically create a comprehensive summary of the meetings, capturing highlights such as project status updates, technical obstacles, or budget discussions. To improve the quality of these outputs, a human-in-the-loop (HITL) process can be included, where domain experts review and refine the summaries to ensure they are accurate and conform to enterprise standards. In parallel, the system can also generate synthetic question-and-answer (Q&A) pairs that can cover common inquiries such as “What are the next steps to be discussed?” or “Who is responsible for delivering the report by Friday?”—questions used to train models for downstream conversational use cases.

[0028] At point 240 (e.g., Model Training Phase III), the Second Language Model (LLM2) is fine-tuned using comprehensive summary and Q&A pairs. This phase can incorporate advanced techniques such as cue word engineering to guide model behavior, RAG weighting to optimize the retrieval of relevant context from a vector database, and metadata filtering to ensure that only high-quality, context-rich inputs are used during training. The result of this phase can be a fine-tuned model that can be optimized at point 240 for enterprise-specific summary and Q&A tasks.

[0029] At point 250 (e.g., the model artifact storage stage), the trained model is saved and made available for fine-tuning as an LLM2. This artifact can be deployed across enterprise tools (e.g., internal meeting assistants, knowledge management systems, or chatbot interfaces) to automatically generate actionable meeting summaries, answer employee questions, and support efficient knowledge retrieval. By combining structured internal data, comprehensive generation, human supervision, and domain-aware fine-tuning, the system ensures that the final AI model delivers high accuracy, context relevance, and enterprise-grade performance.

[0030] Figure 2B Exemplary diagrams of a model for overview purposes, according to one or more embodiments, are shown. For example, Figure 2BFigure 260 illustrates a knowledge-sharing engine. For example, Figure 260 shows how a system can deploy and operationalize a trained AI model within an enterprise environment to perform automated summarization and question-and-answer (Q&A) tasks. The process can begin with a meeting tool (e.g., tool 262) that facilitates real-time or recorded conversations between multiple users. These conversations are transcribed into text, generating meeting transcripts. These transcripts serve as core input to a model that is an intelligent summarization module integrated into enterprise workflows.

[0031] The system can enhance these transcripts using custom templates (e.g., template 264) that take into account meeting type (e.g., daily stand-up, quarterly review, or incident response call) and participant roles (e.g., speaker, recorder, team leader). These templates allow the system to adjust the summary style and content prioritization—for example, emphasizing decision points and deadlines in a project planning meeting, or highlighting risks and action items in a security review.

[0032] The processed transcript is then passed to a model artifact (e.g., artifact 266), which may have been previously trained and deployed to an Enterprise Model Platform (EMP). The artifact can integrate summarization capabilities with Q&A features. The system can leverage guardrails implemented using a language model acting as a judge (e.g., guardrail 268) to evaluate the quality, factual consistency, and tone of the generated summary before the final output. This ensures that the summary is enterprise-safe, unbiased, and context-accurate. For example, guardrails can prevent summaries of speculative or sensitive discussions that are not intended for widespread distribution.

[0033] In the final post-processing stage (e.g., stage 270), the system appends reference links—such as timestamps, anchors to the original transcript, or links to relevant internal documents—to enhance the traceability and usefulness of the summary. The completed summary is then formatted and emailed to users, ensuring that all meeting participants and stakeholders receive a concise, polished review of the conversation.

[0034] Meanwhile, a separate Question-Answering (QnA) interface (e.g., interface 272) allows users to interact with the model through the UX / UI layer. Users can ask natural language questions such as “Who was assigned to the next sprint task?” or “What was the decision to increase the budget?” The system routes these questions to the same deployment model, which uses transcripts from a vector database and additional context to retrieve or generate accurate, context-specific answers.

[0035] It is worth noting that the entire system benefits from Human Feedback Reinforcement Learning (RLHF), in which the model's behavior is continuously fine-tuned by combining user corrections and feedback. For example, if a user marks a summary as incomplete or incorrect, this feedback can be used to adjust the model's weights or cue word structure during future deployments.

[0036] Figure 3 Exemplary components of a system for implementing knowledge sharing, according to one or more embodiments, are shown. For example, Figure 3 Exemplary components for implementing knowledge sharing can be shown. For example... Figure 3 As shown, system 300 may include mobile device 322 and user terminal 324. Although in Figure 3 The mobile device 322 and the user terminal 324 are shown as a smartphone and a personal computer, respectively. However, it should be noted that the mobile device 322 and the user terminal 324 can be any computing device, including but not limited to laptop computers, tablet computers, handheld computers and other computer devices (e.g., servers), including “smart”, wireless, wearable and / or mobile devices. Figure 3 It also includes cloud component 310. Cloud component 310 can alternatively be any computing device as described above and can include any type of mobile terminal, fixed terminal, or other device. For example, cloud component 310 can be implemented as a cloud computing system and can be characterized by one or more component devices. It should also be noted that system 300 is not limited to three devices. For example, a user can use one or more devices to interact with each other, with one or more servers, or with other components of system 300. It should be noted that although one or more operations are described herein as being performed by a specific component of system 300, in some embodiments, these operations can be performed by other components of system 300. As an example, although one or more operations are described herein as being performed by a component of mobile device 322, in some embodiments, these operations can be performed by a component of cloud component 310. In some embodiments, the various computers and systems described herein can include one or more computing devices programmed to perform the described functions. Additionally or alternatively, multiple users can interact with system 300 and / or one or more components of system 300. For example, in one embodiment, a first user and a second user can interact with system 300 using two different components.

[0037] Regarding the components of mobile device 322, user terminal 324, and cloud component 310, each of these devices can receive content and data via an input / output (hereinafter referred to as "I / O") path. Each of these devices may also include a processor and / or control circuitry to send and receive commands, requests, and other suitable data using the I / O path. The control circuitry may include any suitable processing, storage, and / or input / output circuitry. Each of these devices may also include a user input interface and / or user output interface (e.g., a display) for receiving and displaying data. For example, as... Figure 3 As shown, both the mobile device 322 and the user terminal 324 include a display on which data (e.g., session responses, queries, and / or notifications) are displayed.

[0038] Additionally, since mobile device 322 and user terminal 324 are shown as touchscreen smartphones, these displays also serve as user input interfaces. It should be noted that in some embodiments, the device may have neither a user input interface nor a display, and may alternatively use another device (e.g., a dedicated display device such as a computer screen, and / or a dedicated input device such as a remote control, mouse, voice input, etc.) to receive and display content. Furthermore, the device in system 300 may run an application (or another suitable program). The application may cause the processor and / or control circuitry to perform operations related to generating dynamic session responses, queries, and / or notifications.

[0039] Each of these devices may also include electronic storage. Electronic storage devices may include non-transient storage media that electronically store information. The electronic storage media of electronic storage may include one or both of the following: (i) system memory that is integrated with a server or client device (e.g., substantially non-removable), or (ii) removable storage that is removably connectable to a server or client device via, for example, a port (e.g., a USB port, a FireWire port, etc.) or a drive (e.g., a disk drive, etc.). Electronic storage devices may include one or more of the following: optically readable storage media (e.g., optical discs, etc.), magnetically readable storage media (e.g., magnetic tape, magnetic hard disk drives, floppy disk drives, etc.), charge-based storage media (e.g., EEPROM, RAM, etc.), solid-state storage media (e.g., flash drives, etc.), and / or other electronically readable storage media. Electronic storage may include one or more virtual storage resources (e.g., cloud storage, virtual private networks, and / or other virtual storage resources). Electronic storage may store software algorithms, information determined by a processor, information obtained from a server, information obtained from a client device, or other information that implements the functions described herein.

[0040] In some embodiments, System 300 and / or one or more models herein may be implemented using application-specific integrated circuits (ASICs). An integrated circuit can be a small electronic device made of semiconductor material (typically silicon) containing a large number of microscopic electronic components, such as transistors, resistors, capacitors, and diodes. These components are interconnected to perform a specific function or set of functions. Integrated circuits can be classified into various types based on their function, such as analog, digital, and mixed-signal ICs. Transistors within an IC are the primary building blocks, as they act as switches or amplifiers for electronic signals. Other components, such as resistors and capacitors, are used to control voltage, current, and timing within the circuit. System 300 may design the integrated circuits to be application-specific, allowing for the customization of circuit design for a given application. In some embodiments, System 300 may use an integrated circuit system in which one or more integrated circuits are distributed throughout the system, network, and / or one or more devices. In this case, the system design can ensure that the circuitry is integrated with other electronic components, such as connectors, power supplies, and sensors, to form a complete and functional electronic system. This integration allows for the implementation of complex tasks within devices required for one or more specified applications.

[0041] Figure 3 This also includes communication paths 328, 330, and 332. Communication paths 328, 330, and 332 may include the Internet, mobile phone networks, mobile voice or data networks (e.g., 5G or LTE networks), cable networks, public switched telephone networks, or other types of communication networks or combinations thereof. Communication paths 328, 330, and 332 may individually or together include one or more communication paths, such as satellite paths, fiber optic paths, cable paths, paths supporting Internet communications (e.g., IPTV), free-space connections (e.g., for broadcasting or other wireless signals), or any other suitable wired or wireless communication paths or combinations thereof. The computing device may include additional communication paths linking multiple hardware, software, and / or firmware components that operate together. For example, the computing device may be implemented by a cloud, a computing platform operating as the computing device.

[0042] Cloud component 310 may include model 302, which may be a machine learning model, an artificial intelligence model, etc. (collectively referred to herein as "model"). In recent years, the use of artificial intelligence has grown exponentially, including but not limited to machine learning, deep learning, etc. (collectively referred to herein as artificial intelligence model, machine learning model, or simply model). Broadly speaking, artificial intelligence refers to a wide branch of computer science that involves building intelligent machines capable of performing tasks that typically require human intelligence. A key benefit of artificial intelligence is its ability to process data, find underlying patterns, and / or perform real-time determination. However, despite these benefits and despite a wide range of potential applications, the practical implementation of artificial intelligence is hampered by several technical challenges. First, artificial intelligence may rely on large amounts of high-quality data. The process of acquiring this data and ensuring its high quality can be complex and time-consuming. Additionally, the acquired data may need to be accurately classified and labeled, which can be a difficult, time-consuming, and manual task. Second, despite the mainstream popularity of artificial intelligence, the practical implementation of artificial intelligence may require expertise to design, program, and integrate AI-based solutions, which may limit the number of personnel and resources available to create these practical implementations. Finally, AI-based results may be difficult to audit because the processes that produce the results may be unknown or obscure. This ambiguity may hinder the identification of errors and the improvement of the models that provide the results.

[0043] Model 302 can take input 304 and provide output 306. The input may include multiple datasets, such as training datasets and test datasets. Each of the multiple datasets (e.g., input 304) may include a subset of data related to user data, predicted forecasts and / or errors, and / or actual forecasts and / or errors. In some embodiments, output 306 may be fed back to model 302 as input to train model 302 (e.g., alone or in combination with user indications of the accuracy of output 306, labels associated with the input, or other reference feedback information). For example, the system may receive a first labeled feature input, wherein the first labeled feature input is labeled with a known prediction for the first labeled feature input. The system may then train a first machine learning model to classify the first labeled feature input using the known prediction (e.g., short phrase, label or short phrase, whether the short phrase corresponds to a labeled short phrase, etc.).

[0044] In various embodiments, model 302 can update its configuration (e.g., weights, biases, or other parameters) based on an evaluation of its predictions (e.g., output 306) and reference feedback information (e.g., user indications of accuracy, reference labels, or other information). In various embodiments where model 302 is a neural network, connection weights can be adjusted to reconcile discrepancies between the neural network's predictions and reference feedback. In further use cases, one or more neurons (or nodes) of the neural network may need to backpropagate their respective errors through the neural network to facilitate the update process (e.g., error backpropagation). For example, updates to connection weights could reflect the magnitude of the error backpropagated after the forward pass is complete. In this way, for example, model 302 can be trained to generate better predictions.

[0045] In some embodiments, model 302 may include an artificial neural network. In such embodiments, model 302 may include an input layer and one or more hidden layers. Each neuron of model 302 may be connected to many other neurons of model 302. Such connections may be enforced or inhibited in terms of their influence on the activation state of the connected neurons. In some embodiments, each individual neuron may have a summation function that combines the values ​​of all its inputs. In some embodiments, each connection (or the neuron itself) may have a threshold function such that a signal must exceed it before propagating to other neurons. Model 302 may be self-learning and trained rather than explicitly programmed, and may perform significantly better in certain domains of problem-solving compared to conventional computer programs. During training, the output layer of model 302 may correspond to a classification of model 302, and inputs known to correspond to that classification may be input into the input layer of model 302 during training. During testing, inputs without a known classification may be input into the input layer, and the determined classification may be output.

[0046] In some embodiments, model 302 may include multiple layers (e.g., where signal paths traverse from front layers to back layers). In some embodiments, model 302 may utilize backpropagation techniques, where forward stimulation is used to reset weights on “pre-” neurons. In some embodiments, stimulation and inhibition of model 302 may be more free-flowing, where connections interact in a more chaotic and complex manner. During testing, the output layer of model 302 may indicate whether a given input corresponds to a classification of model 302 (e.g., short phrase, label or short phrase, whether a short phrase corresponds to a labeled short phrase, etc.).

[0047] In some embodiments, the model (e.g., model 302) may automatically perform actions based on output 306. In some embodiments, the model (e.g., model 302) may not perform any actions. The output of the model (e.g., model 302) may be used to generate a summary of a user interface session.

[0048] In some embodiments, the system can generate predictions related to financial services. For example, the system may use one or more models and / or applications to process various data to generate predictions for tasks such as payment card eligibility determination, fraud detection, and / or determining rates for auto finance applications. For credit card eligibility, the model may use data such as the applicant's credit score, income, employment history, debt-to-income ratio, and past credit history. This data helps the model predict the likelihood of the applicant repaying credit card debt. For fraud detection, the model analyzes transaction data, including the amount, location, frequency, and patterns of transactions. They compare these patterns with known fraudulent activities to identify potential fraudulent activity. To determine auto finance rates, the model may use the applicant's credit score, loan amount, loan term, vehicle details, and market interest rates. The data used by these models comes from various sources, including credit bureaus, financial institutions, customer-provided information, transaction records, and public records. By analyzing these data points, the model can make evidence-based predictions and decisions, helping financial institutions manage risk, provide appropriate services, and improve customer satisfaction.

[0049] In some embodiments, the model can process the received data through several stages. For example, the model can collect and aggregate data from various sources, such as user accounts, industry data, third-party data sources, etc. The system can ensure that the data is cleaned and preprocessed to handle any missing and / or inconsistent information. This preprocessing may include normalizing numerical data, encoding categorical variables, and applying techniques to handle outliers. The model can then use feature engineering to identify and create relevant features that can improve its predictive power. For example, the system can derive new variables from existing variables, such as calculating the debt-to-income ratio from debt and income data.

[0050] Once the data is ready, the system feeds it into a model, which can be an artificial intelligence algorithm such as logistic regression, decision trees, and / or neural networks. The model can be trained on historical data, learning patterns, and / or the relationship between input features and target outcomes. During this training process, the system can adjust model parameters to minimize prediction error. After training, the system can use a separate dataset to validate and test the model to ensure it has predetermined and / or threshold accuracy and generalizability.

[0051] In some embodiments, the system may use task-specific predictions. Additionally or alternatively, the system may tailor its inputs and / or outputs based on the desired determinations and / or predictions. For example, for credit card eligibility, the model may assess the likelihood of an applicant defaulting on payments. In fraud detection, the model may identify anomalies and patterns indicating fraudulent activity. In auto finance interest rate determination, the model may predict the risk associated with lending to individuals and adjust interest rates accordingly. In some embodiments, the entire process may be iterative, with models continuously updated and refined as new data becomes available to ensure they remain effective in making accurate and reliable predictions.

[0052] System 300 also includes an API layer 350. API layer 350 allows the system to generate profiles across different devices. In some embodiments, API layer 350 may be implemented on mobile device 322 or user terminal 324. Alternatively or additionally, API layer 350 may reside on one or more cloud components 310. API layer 350 (which may be a REST or Web services API layer) can provide a decoupled interface to data and / or functionality of one or more applications. API layer 350 can provide a public, language-agnostic way to interact with applications. Web services APIs provide a well-defined contract, called WSDL, which describes the service based on its operations and the types of information used to exchange information. REST APIs typically do not have this contract; instead, they are documented with client libraries in most common languages, including Ruby, Java, PHP, and JavaScript. SOAP Web services have traditionally been used in enterprises to publish internal services and to exchange information with partners in B2B transactions.

[0053] API layer 350 can be used in various architectural layouts. For example, system 300 can be partially based on API layer 350, enabling strong adoption of SOAP and RESTful web services, using resources such as service repositories and developer portals, but with low management, standardization, and separation of concerns. Alternatively, system 300 can be entirely based on API layer 350, ensuring separation of concerns between layers such as API layer 350, services, and applications.

[0054] In some embodiments, the system architecture can use a microservices approach. Such systems can use two types of layers: a front-end layer and a back-end layer where microservices reside. In this architecture, the role of API layer 350 is to provide integration between the front-end and back-end. In this case, API layer 350 can use a RESTful API (exposed to communication between the front-end or even microservices). API layer 350 can use AMQP (e.g., Kafka, RabbitMQ, etc.). API layer 350 can also utilize newer communication protocols such as gRPC and Thrift for initial use.

[0055] In some embodiments, the system architecture may use an open API approach. In this case, API layer 350 may use commercial or open-source API platforms and their modules. API layer 350 may use a developer portal. API layer 350 may use strong security constraints with WAF and DDoS protection applied, and API layer 350 may use RESTful APIs as the standard for external integration.

[0056] Figure 4 A flowchart illustrating the steps involved in implementing knowledge sharing according to one or more embodiments is shown. For example, a system may use process 400 (e.g., as implemented on one or more system components described above) to implement a knowledge sharing engine based on speech signal processing during a user interface session.

[0057] At step 402, process 400 (e.g., using one or more of the components described above) detects short phrases. For example, the system may receive a first audio input during a first user interface session between multiple users, generate a first text string based on the first audio input, and parse the first text string to detect the first short phrase. For example, the system may detect short phrases by analyzing spoken or written content of condensed expressions commonly used in a particular domain or conversational context. For example, during a first user interface session between multiple users, the system may receive a first audio input and convert it into a first text string using a speech-to-text engine or another speech signal processing algorithm. Once the spoken content is transcribed into text, the system parses the text string to detect the first short phrase—such as an abbreviation, acronym, or symbolic reference (e.g., “ETA,” “CPU,” or “@user”). This detection involves scanning language patterns such as sequences of all capital letters, known abbreviations from a domain-specific dictionary, or symbols that carry meaning depending on their context. The system may also use contextual analysis to distinguish short phrases from regular words, identifying how they are used relative to other terms. For example, if the phrase “ETA” appears near words such as “arrive” or “expected,” the system can infer that it refers to “estimated time of arrival.” By accurately detecting these short phrases, the system can enrich the summary, improve transcriptional clarity, and support more nuanced suggestions or follow-up actions during or after the session.

[0058] At step 404, process 400 (e.g., using one or more of the components described above) determines whether the first short phrase corresponds to a short phrase of one or more tags. For example, in response to detecting the first short phrase, the system can determine whether the first short phrase corresponds to a short phrase of one or more tags. In response to detecting the first short phrase, the system can determine whether it corresponds to a short phrase of one or more tags by comparing it with a reference database or knowledge base containing known short phrases and their associated meanings or tags. Once the system identifies a potential short phrase (such as an acronym or abbreviation), it performs a lookup to see if the phrase matches any entry in the tag's dataset. These tag short phrases can be domain-specific and include metadata such as full extensions, usage examples, and contextual associations. The system can enhance the matching process by considering the context in which the short phrase is used, analyzing surrounding words, speaker roles, or discussion topics. For example, the phrase "AI" can be interpreted as "artificial intelligence" in the technology field or "appreciation index" in finance. The system can use natural language processing techniques and domain profiles to evaluate the context and confirm whether the detected phrase aligns with an entry of one or more tags. If a match is found, the system associates the short phrase with its tag, enabling it to be accurately interpreted, expanded, or used to generate summaries, recommendations, or other interface content.

[0059] In some embodiments, the system may determine whether a first short phrase corresponds to one or more tagged short phrases by: parsing a second text string to detect a second short phrase, determining whether the second short phrase corresponds to the first short phrase, and, in response to determining that the second short phrase corresponds to the first short phrase, determining whether the second short phrase corresponds to one or more tagged short phrases. For example, the system may determine whether the first short phrase corresponds to one or more tagged short phrases by utilizing additional contextual data, such as the second text string, to support disambiguation and validation. After detecting the first short phrase in the main text string, the system may parse a second text string (from a different part of the conversation, related documents, or input from another user during the same session) to detect the second short phrase. The system then uses techniques such as string matching, contextual analysis, or semantic similarity scoring to compare the second short phrase with the first short phrase to determine whether they are equivalent or closely related. If the system determines that the second short phrase corresponds to the first short phrase, for example, if both are instances of “NLP” used in slightly different sentence structures, it considers the second occurrence as conclusive evidence. The system then checks whether the second short phrase matches any entry in a tagged dataset of known phrases. If a match is found, it is inferred that the first short phrase also corresponds to the same tagged entry. This process enhances the system's confidence in the interpretation by validating the phrase in multiple instances or contexts, reducing the chance of misclassification and enabling more accurate content generation, such as summaries or recommendations.

[0060] In some embodiments, the system can determine whether the first short phrase corresponds to one or more tagged short phrases by parsing a second text string to detect the context of the first short phrase, generating a contextual short phrase based on the second text string and the first short phrase, and determining whether the contextual short phrase corresponds to one or more tagged short phrases. For example, the system can determine whether the first short phrase corresponds to one or more tagged short phrases by utilizing the context from the second text string. After detecting the first short phrase in the main text string, the system parses the second text string—such as adjacent sentences, related conversation fragments, or supporting documents—to identify contextual information related to the short phrase. This context may include domain-specific terms, topic indicators, or descriptive language that helps clarify the expected meaning of the short phrase. Using this context, the system generates a contextual short phrase that combines the original phrase with its inferred meaning or domain usage. For example, if the first short phrase is “RAM” and the second text string includes terms such as “memory upgrade,” “hardware,” or “system performance,” the system can generate a contextual short phrase such as “RAM (Random Access Memory).” It then compares this contextual version with a store of tagged short phrases to determine if it corresponds to a known entry. If a match is found, the system will more accurately determine the meaning of the first short phrase, enabling it to generate a clearer explanation, summary, or suggestion that aligns with the user's intent and the domain of the session.

[0061] In some embodiments, the system can determine whether the first short phrase corresponds to one or more tagged short phrases by parsing a second text string to detect the context of the first short phrase, generating a contextual short phrase based on the second text string and the first short phrase, and determining whether the contextual short phrase corresponds to one or more tagged short phrases. For example, the system can determine whether the first short phrase corresponds to one or more tagged short phrases by incorporating contextual understanding derived from the second text string. After detecting the first short phrase (such as an acronym or abbreviation) in the main text string, the system parses the second text string, which may originate from surrounding conversations, related documents, or another segment within the same session. The purpose of parsing the second text string is to identify contextual clues that can clarify the expected meaning of the short phrase—such as associated terms, domain-specific language, or descriptive phrases. Based on this analysis, the system generates a contextual short phrase by combining the original short phrase with its inferred meaning derived from the detected context. For example, if the first short phrase is “API” and the second text string contains words such as “developer access,” “integration,” or “endpoint,” the system can generate the contextual short phrase “API (Application Programming Interface).” It then compares this contextual version with a set of short phrases for tags stored in a reference dataset or knowledge base. If the contextual short phrase matches an entry for one or more tags, the system concludes that the original phrase corresponds to the identified tag, increasing confidence in its interpretation and enabling accurate downstream processing such as content generation, summarization, or decision support.

[0062] In some embodiments, the system may determine whether a first short phrase corresponds to one or more tagged short phrases by: determining a first relevance of the first short phrase to a first user interface session; comparing the first relevance to a threshold relevance; and determining, based on the first relevance and the threshold relevance, whether to compare the first short phrase to one or more tagged short phrases. For example, the system may determine whether a first short phrase corresponds to one or more tagged short phrases by first assessing the relevance of the phrase to the context of the ongoing user interface session. This process first assesses the degree of consistency between the short phrase and the topic, domain, or participant role of the activity in the session. For example, the system may analyze session metadata, previous discourse, user roles, or session trends to calculate a first relevance score for the short phrase. This score reflects the likelihood that the phrase is meaningful or context-sensitive in the current session. The system then compares this relevance score to a threshold relevance value, which represents the minimum importance required to justify further processing (e.g., disambiguation or expansion). If the first relevance meets or exceeds the threshold, the system continues to compare the short phrase to a database of tagged short phrases to determine if a match exists. This selective approach helps the system focus its computational resources on context-sensitive phrases, avoiding unnecessary searches or misinterpretations of accidental or out-of-context abbreviations, thereby improving the efficiency and accuracy of content generation and user interface interaction.

[0063] In some embodiments, the system can determine whether a first short phrase corresponds to one or more tagged short phrases by updating one or more tagged short phrases to include the first tagged short phrase and assigning the first tagged short phrase to the first short phrase. For example, the system can determine whether a first short phrase corresponds to one or more tagged short phrases by dynamically updating its tagged phrase database to include new, previously unrecognized short phrases. When the system detects a first short phrase that does not initially match any entry in its existing set of tagged phrases, it can analyze the surrounding context—such as relevant text, user feedback, or repetition patterns—to infer a possible meaning. If the system determines that the inferred meaning is valid and accurate in the context, it can generate a first tagged short phrase that defines or expands the detected short form. The system then updates its tagged dataset to include the new mapping by associating the first tagged short phrase with the original short phrase. This task effectively expands the system's knowledge base, enabling it to recognize and interpret newly added phrases in future user interface sessions. By continuously learning from context and updating its internal references, the system becomes more robust and adaptive, thereby improving its ability to interpret domain-specific or evolving languages ​​in real time.

[0064] At step 406, process 400 (e.g., using one or more of the components described above) determines a domain. For example, in response to determining that a first short phrase does not correspond to a short phrase marked with one or more tags, the system can determine a first domain corresponding to one or more of a plurality of users. In response to determining that a first short phrase does not correspond to a short phrase marked with one or more tags, the system can attempt to resolve ambiguity by identifying a first domain corresponding to one or more users participating in a user interface session. To do this, the system analyzes user-specific data such as the role, profile, organizational unit, or previous interaction history of the suggested domain affiliation (such as cybersecurity, healthcare, finance, or customer support). For example, if a participant in the session is identified as a network administrator or an employee of the IT department, the system can infer that the relevant domain is cybersecurity or enterprise IT. This domain inference is crucial because the meaning of a short phrase often varies depending on the context; for example, “IP” can refer to “Internet Protocol” in the technical field or “intellectual property” in the legal field. By determining a first domain associated with one or more users, the system narrows the scope of interpretation and can more accurately assess or even generate contextual labels for short phrases, thereby improving the relevance and accuracy of system-generated content (e.g., summaries, recommendations, or automatic annotations).

[0065] In some embodiments, the system can determine the first domain corresponding to one or more of the multiple users by identifying a first user among one or more of the multiple users who corresponds to the first audio input and by determining that the first user corresponds to a first domain. For example, the system can determine the first domain corresponding to one or more of the multiple users by first identifying which user among the users participating in the session provided the first audio input. This can be achieved through speech recognition, metadata tagging, or session-based user tracking that links spoken input to a specific user profile. Once the system determines that the first user is the source of the audio input containing the short phrase, it accesses stored information about that user, such as their organizational role, department, job title, or usage history, to infer their associated domain. For example, if the user is known to be a software engineer, the system can associate them with the technology or development domain; if the user is a financial analyst, the system can infer the finance domain. By establishing this connection, the system determines that the first user corresponds to the first domain, which is then used as a context filter for interpreting the short phrase. This domain-specific context allows the system to analyze, tag, or expand the short phrase more accurately, thereby ensuring that any generated content is consistent with the professional language and expectations of the user's domain.

[0066] At step 408, process 400 (e.g., using one or more of the components described above) retrieves a domain profile. For example, the system may retrieve a first domain profile corresponding to a first domain. The system can retrieve a first domain profile corresponding to a first domain by accessing a structured database or knowledge repository of domain profiles using the identified domain as a keyword. Each domain profile contains a set of characteristics, such as domain-specific terminology, common short phrases, contextual patterns, user roles, and communication styles associated with that domain. Once the system determines the first domain based on user roles, session context, or input content, it queries the repository to locate the matching domain profile. For example, if the domain is identified as "cybersecurity," the system retrieves the corresponding profile, which includes relevant acronyms such as "IDS" (Intrusion Detection System), typical usage patterns, and a language model trained on cybersecurity-related data. The retrieved profile provides the system with contextual information to interpret ambiguous input, detect relevant entities, and generate accurate summaries or recommendations. The domain profile acts as a contextual perspective, enabling the system to tailor its understanding and output to align with the specific expectations, vocabulary, and communication norms of the identified domain.

[0067] At step 410, process 400 (e.g., using one or more of the components described above) generates feature input. For example, the system can generate a first feature input corresponding to a first short phrase and a first domain profile. The system can generate the first feature input corresponding to the first short phrase and the first domain profile by combining language and contextual information into a structured format suitable for model processing or classification. After detecting the first short phrase and retrieving the associated first domain profile, the system extracts key attributes from two sources. From the short phrase, it can capture the raw text, character patterns, position within the sentence, surrounding words, and any detected formatting prompts (e.g., capitalization or punctuation). From the domain profile, it collects contextual features such as known extensions of similar phrases, domain-specific vocabulary, semantic relations, and probability distributions of term usage. The system then encodes this combined information (text and context) into a feature vector or structured input, which includes fields such as “phrase text,” “domain context,” “co-occurring terms,” and “domain-specific match confidence.” This initial feature input serves as the basis for further processing by a classification or prediction model, allowing the system to evaluate whether the short phrase matches a known label, requires disambiguation, or should be added to the labeled dataset. The resulting feature input ensures that the system's interpretation is based on the phrase's textual content and the broader domain-specific context.

[0068] In some embodiments, the system can generate a first feature input by determining a second domain corresponding to a first session type of a first user interface session and retrieving a second domain profile corresponding to the second domain, wherein the first feature input is further based on the second domain. For example, the system can generate the first feature input by incorporating additional context derived from the second domain corresponding to the first session type of the first user interface session. The system begins by identifying the session type—such as a group video conference, technical support call, financial review, or collaborative document editing session—which provides clues about the general nature and purpose of the interaction. Based on the session type, the system determines a second domain that reflects the broader operational or session context; for example, a financial review session may be linked to a finance domain, even if the participants come from different departments. The system then retrieves a second domain profile corresponding to the second domain, which contains relevant terminology, phrase usage patterns, and contextual features. When generating the first feature input for a detected short phrase, the system combines attributes from a first domain profile (linked to a specific user role) and a second domain profile (linked to the session type). This enriches the feature input, giving it a more comprehensive view of the language and context, thereby improving the system's ability to accurately classify, expand, or interpret short phrases. By establishing feature inputs in user-specific and session-level domains, the system enhances its adaptability and semantic accuracy.

[0069] In some embodiments, the system can generate a first feature input by determining a first role corresponding to one or more users among a plurality of users and retrieving a second domain profile corresponding to the first role, wherein the first feature input is also based on the second domain. For example, the system can generate the first feature input by incorporating contextual information derived from the first role of one or more users participating in a user interface session. The process begins by determining the user's role—such as engineer, project manager, financial analyst, or customer support representative—based on user metadata, profile information, or system permissions. Once the system identifies the first role, it maps it to a corresponding second domain that reflects the typical operational context of the role. For example, the role of "financial analyst" may correspond to the finance domain, while "software engineer" may correspond to the technology or development domain. The system then retrieves a second domain profile associated with that domain, which includes role-specific terminology, short phrase usage, communication patterns, and contextual rules. When generating the first feature input for a detected short phrase, the system includes not only the textual characteristics of the phrase itself but also features derived from the second domain profile—such as the expected meaning of acronyms or commonly used phrases by individuals within that role. By basing feature inputs on the contextual relevance of phrases and user roles, the system enhances its ability to accurately disambiguate, classify, and interpret phrases, thereby supporting smarter content generation and user interaction.

[0070] In some embodiments, the system can generate a first feature input by determining a second user interface session corresponding to a first user interface session, retrieving a second text string corresponding to the second user interface session, and determining a first context for the first short phrase based on the second text string, wherein the first feature input is further based on the first context. For example, the system can generate the first feature input by leveraging information from the relevant second user interface session to enrich the contextual understanding of the first short phrase detected in the first user interface session. The system begins by identifying a second session corresponding to the first session (such as a previous meeting, chat thread, or collaborative session involving the same users, domain, or topic) based on session metadata, shared participants, timestamps, or reference materials. It then retrieves a second text string from the second session, which may include transcripts, messages, comments, or other content relevant to the current discussion. The system analyzes the second text string to determine a first context for the short phrase by recognizing the use of surrounding terms, topics, or similar phrases previously expanded. For example, the context may reveal that a short form such as “ML” is used in the second session to represent “machine learning,” thus implying the same meaning in the current session. The system uses this inferred context to generate a first feature input, which combines the textual attributes of the short phrase with contextual indicators derived from the second session. By grounding the feature input in a broader historical or collaborative context, the system enhances its ability to accurately interpret, classify, and act on short phrases within the current user interface session.

[0071] In some embodiments, the system can generate a first feature input by determining a second user interface session corresponding to a first user interface session and a second domain profile corresponding to the second user interface session, wherein the first feature input is further based on the second domain profile. For example, the system can generate the first feature input by identifying a second user interface session corresponding to the first user interface session and leveraging contextual domain knowledge associated with that second session. The system first analyzes metadata such as session participants, topics discussed, timestamps, or linked resources to determine a context-relevant second session—e.g., a previous meeting, chat log, or collaborative document review involving similar users or topics. Once the corresponding second session is identified, the system infers or retrieves a second domain profile characterizing the domain of that session. This domain profile includes structured information such as common terms, short phrase definitions, domain-specific acronyms, typical user roles, and communication patterns associated with the previous session. The system then uses the domain profile to enrich the first feature input, which is constructed to interpret short phrases detected in the current session. By incorporating attributes from the second domain profile (such as possible meanings or contextual cues), the feature input becomes more robust and evidence-based, enabling a more accurate interpretation, classification, or expansion of the short phrases. This approach allows the system to benefit from prior domain knowledge, thereby improving semantic understanding and enhancing real-time language processing in ongoing conversations.

[0072] In some embodiments, the system can generate a first feature input by identifying a first acronym corresponding to a first domain profile and determining whether the first acronym corresponds to a first short phrase. For example, the system can generate the first feature input by using the first domain profile to identify commonly used acronyms within that domain and then comparing them to the detected first short phrase. After retrieving or constructing the domain profile (based on factors such as user role, session type, or historical usage), the system accesses a curated list of acronyms associated with that domain. It then searches the list using precise string matching, abbreviation patterns, or semantic similarity to determine if any first acronym matches or is very similar to the detected short phrase. If a match is found, indicating that the first acronym corresponds to the first short phrase, the system incorporates that relationship into the first feature input. This feature input may include fields such as the short phrase itself, the matching acronym, the confidence score of the match, and contextual clues from the domain profile. By establishing links between acronyms and phrases within a domain-specific context, the system enhances its ability to accurately interpret and classify phrases. This rich feature input can then be used for further processing, such as determining appropriate labels, generating summaries, or improving natural language understanding within the user interface session.

[0073] In some embodiments, the system can generate a first feature input by determining a first category corresponding to a first domain profile and using the first category to determine a first context for the first short phrase. For example, the system can generate the first feature input by first identifying a first category corresponding to the first domain profile. This category is a structured hierarchy or classification of domain-specific concepts, terms, and relationships—such as a technology category in cybersecurity, a financial term in banking, or a clinical category in healthcare. Once the category is retrieved, the system uses it to interpret the first short phrase by mapping the phrase to entries in the category to identify related concepts, using category or hierarchical associations. This mapping helps the system infer the first context of the short phrase by revealing how the short phrase fits into the conceptual structure of the domain. For example, if the short phrase is “SOC” and the category places it under “Security Operations” within the cybersecurity domain, the system interprets it as “Security Operations Center”. This contextual understanding is then encoded into the first feature input, which may include the phrase itself, its associated category node, related terms, and a context relevance score. By basing the feature input on a domain classification, the system ensures that subsequent processing (such as classification, expansion, or recommendation) is semantically accurate and conforms to domain-specific expectations.

[0074] In some embodiments, the system can generate a first feature input by determining a first data storage location corresponding to a first domain profile and generating a knowledge base for a first model based on content from the first data storage location. For example, the system can generate the first feature input by first identifying a first data storage location corresponding to a first domain profile. This data storage location—such as a secure server, document repository, cloud storage, or enterprise knowledge base—contains domain-specific content, such as technical documents, strategy manuals, past conversations, or domain-related tagged datasets. Once the system determines the storage location, it extracts and analyzes its content to build or update a knowledge base customized for the first model. This knowledge base may include short phrases, domain-specific acronyms, contextual patterns, and definitions of relationships between terms, all structured to support interpretation and classification tasks. When generating the first feature input for detected short phrases, the system extracts from this knowledge base to enrich the input with contextual insights—such as possible meanings, usage examples, semantic categories, or co-occurrence frequencies. This enriched feature input is then formatted to conform to the model's input patterns, enabling the model to more accurately interpret and classify short phrases within the domain context. By building feature inputs onto validated domain-relevant data, the system improves the accuracy and reliability of its language understanding capabilities.

[0075] At step 412, process 400 (e.g., using one or more of the components described above) generates a summary based on feature input. For example, the system may input a first feature into a first model to determine a short phrase with a first tag, generate a first summary corresponding to a first user interface session based on the short phrase with the first tag, and generate a first summary for display on the user interface. For example, the system may input a first feature into a first model to determine a short phrase with a first tag for a detected first short phrase by inputting structured feature data (including context, language, and domain-specific attributes) into the model's inference engine. A model trained on domain-aware language patterns and short phrase interpretation processes the input and outputs a tagged version of the phrase, such as expanding "API" to "Application Programming Interface" based on the surrounding context and domain profile. In the case of a short phrase with the first tag identified, the system incorporates it into a broader semantic understanding of the ongoing first user interface session. Using a natural language generation or summarization algorithm, the system then compiles a first summary that accurately reflects the content and key points of the session, now enriched with correctly interpreted short phrases. Finally, the system formats the summary for user consumption and generates it to display on the user interface—such as in the transcript pane, session review card, or notification alert—allowing users to quickly understand and recall important session highlights and improving clarity and domain relevance.

[0076] In some embodiments, the system can train a first model by receiving a first set of parameter tweaks at a first frequency and a second set of parameter tweaks at a second frequency. For example, the system can train the first model by receiving a first set of parameter tweaks at a first frequency and a second set of parameter tweaks at a second frequency, combined with multi-layer parameter tweaking. The first set can represent periodic, high-frequency updates based on incoming data streams, such as user interactions, session feedback, or real-time validation events. These tweaks allow the model to quickly adapt to changing patterns or terms, especially in dynamic environments. In parallel, the second set of parameter tweaks can occur at a lower frequency and can be derived from more comprehensive fine-tuning sources, such as periodic model evaluations, human-in-the-loop reviews, or batch retraining using larger labeled datasets. These lower-frequency updates ensure that the model maintains long-term stability, accuracy, and consistency with evolving domain knowledge. By managing high-frequency, fine-tuning updates and low-frequency, structural tweaks, the system supports a balanced training strategy that allows the first model to remain responsive to immediate usage trends and based on fundamental knowledge, thereby improving its performance over time.

[0077] expected Figure 4 The steps or descriptions herein can be used in conjunction with any other embodiment of this disclosure. Additionally, regarding... Figure 4The described steps and descriptions may be performed in an alternative order or in parallel to further achieve the objectives of this disclosure. For example, each of these steps may be performed in any order, in parallel, or simultaneously to reduce lag or increase the speed of the system or method. Furthermore, it should be noted that any component, device, or apparatus associated with the foregoing figures may be used to perform this action. Figure 4 One or more steps in the process.

[0078] The embodiments described above are presented for illustrative purposes and not for limitation, and this disclosure is limited only by the appended claims. Furthermore, it should be noted that the features and limitations described in any embodiment can be applied to any embodiment herein, and flowcharts or examples associated with one embodiment can be combined with any other embodiment in a suitable manner, performed in a different order, or performed in parallel. Additionally, the systems and methods described herein can be performed in real time. It should also be noted that the above systems and / or methods can be applied to other systems and / or methods, or used according to other systems and / or methods.

[0079] The following examples will provide a better understanding of this technology:

[0080] 1. A method for implementing a knowledge-sharing engine based on speech signal processing during a user interface session.

[0081] 2. The method according to any one of the foregoing embodiments further includes: receiving a first audio input during a first user interface session among a plurality of users; generating a first text string based on the first audio input; parsing the first text string to detect a first short phrase; determining, in response to detecting the first short phrase, whether the first short phrase corresponds to one or more tagged short phrases; determining, in response to determining that the first short phrase does not correspond to the one or more tagged short phrases, a first domain corresponding to one or more of the plurality of users; retrieving a first domain profile corresponding to the first domain; generating a first feature input corresponding to the first short phrase and the first domain profile; inputting the first feature input into a first model to determine a short phrase with a first tagged meaning of the first short phrase; generating a first summary corresponding to the first user interface session based on the first tagged short phrase; and generating the first summary for display on a user interface.

[0082] 3. The method according to any one of the foregoing embodiments, wherein generating the first feature input further includes: determining a second domain corresponding to a first session type of the first user interface session; and retrieving a second domain profile corresponding to the second domain, wherein the first feature input is further based on the second domain.

[0083] 4. The method according to any one of the foregoing embodiments, wherein generating the first feature input further includes: determining a first role corresponding to one or more of the plurality of users; and retrieving a second domain profile corresponding to the first role, wherein the first feature input is further based on the second domain.

[0084] 5. The method according to any one of the foregoing embodiments, wherein generating the first feature input further includes: determining a second user interface session corresponding to the first user interface session; retrieving a second text string corresponding to the second user interface session; and determining a first context of the first short phrase based on the second text string, wherein the first feature input is further based on the first context.

[0085] 6. The method according to any one of the foregoing embodiments, wherein generating the first feature input further includes: determining a second user interface session corresponding to the first user interface session; and determining a second domain profile corresponding to the second user interface session, wherein the first feature input is further based on the second domain profile.

[0086] 7. The method according to any one of the foregoing embodiments, wherein determining whether the first short phrase corresponds to a short phrase of the one or more tags further comprises: parsing a second text string to detect a second short phrase; determining whether the second short phrase corresponds to the first short phrase; and in response to determining that the second short phrase corresponds to the first short phrase, determining whether the second short phrase corresponds to a short phrase of the one or more tags.

[0087] 8. The method according to any one of the foregoing embodiments, wherein determining whether the first short phrase corresponds to a short phrase of the one or more tags further comprises: parsing a second text string to detect the context of the first short phrase; generating a contextual short phrase based on the second text string and the first short phrase; and determining whether the contextual short phrase corresponds to a short phrase of the one or more tags.

[0088] 9. The method according to any one of the foregoing embodiments, wherein determining whether the first short phrase corresponds to a short phrase of the one or more tags further comprises: parsing a second text string to detect the context of the first short phrase; generating a contextual short phrase based on the second text string and the first short phrase; and determining whether the contextual short phrase corresponds to a short phrase of the one or more tags.

[0089] 10. The method according to any one of the foregoing embodiments, wherein determining whether the first short phrase corresponds to a short phrase of the one or more tags further comprises: determining a first relevance of the first short phrase to the first user interface session; comparing the first relevance with a threshold relevance; and determining, based on the first relevance and the threshold relevance, to compare the first short phrase with a short phrase of the one or more tags.

[0090] 11. The method according to any one of the foregoing embodiments, wherein determining the short phrase of the first tag for the first short phrase further comprises: updating the short phrases of the one or more tags to include the short phrase of the first tag; and assigning the short phrase of the first tag to the first short phrase.

[0091] 12. The method according to any one of the foregoing embodiments, wherein determining the first domain corresponding to one or more of the plurality of users further comprises: determining that a first user among the one or more of the plurality of users corresponds to the first audio input; and determining that the first user corresponds to the first domain.

[0092] 13. The method according to any one of the foregoing embodiments, wherein the first model is trained by receiving a first set of parameter adjustments at a first frequency and receiving a second set of parameter adjustments at a second frequency.

[0093] 14. The method according to any one of the foregoing embodiments, wherein generating the first feature input corresponding to the first short phrase and the first domain profile further includes: determining a first acronym corresponding to the first domain profile; and determining whether the first acronym corresponds to the first short phrase.

[0094] 15. The method according to any one of the foregoing embodiments, wherein generating the first feature input corresponding to the first short phrase and the first domain profile further includes: determining a first category corresponding to the first domain profile; and using the first category to determine a first context of the first short phrase.

[0095] 16. The method according to any one of the foregoing embodiments, wherein generating the first feature input corresponding to the first short phrase and the first domain profile further includes: determining a first data storage location corresponding to the first domain profile; and generating a knowledge base for the first model based on content from the first data storage location.

[0096] 17. One or more non-transitory computer-readable media storing instructions that, when executed by a data processing apparatus, cause the data processing apparatus to perform operations including any one of embodiments 1-16.

[0097] 18. A system comprising: one or more processors; and a memory storing instructions, which, when executed by the processors, cause the processors to perform operations including any of the operations in embodiments 1-16.

[0098] 19. A system comprising means for performing any one of embodiments 1-16.

Claims

1. A system for implementing a knowledge-sharing engine based on speech signal processing during a user interface session, the system comprising: One or more processors; as well as One or more non-transitory computer-readable media including instructions that, when executed by the one or more processors, cause operations including: Receive the first audio input during a first user interface session among multiple users; The first text string is generated by applying a first speech signal processing algorithm to the first audio input. Parse the first text string to detect acronyms in the first language; In response to detecting the first language acronym, determine whether the first language acronym corresponds to one or more tagged language acronyms; In response to determining that the first language acronym does not correspond to the language acronym of the one or more tags: Determine a first domain corresponding to one or more of the plurality of users; Determine the second field corresponding to the first session type of the first user interface session; Retrieve the first field profile corresponding to the first field; Retrieve the second field profile corresponding to the second field; A first summary corresponding to the first user interface session is generated based on the language acronym of the first tag, wherein the language acronym of the first tag is determined by processing the first language acronym, the first domain profile, and the second domain profile in the model; and This causes the first summary to be displayed on the user interface.

2. A method for implementing a knowledge-sharing engine based on speech signal processing during a user interface session, the method comprising: Parse a first text string to detect a first short phrase, wherein the first text string is based on a first audio input received during a first user interface session among multiple users; In response to determining that the first short phrase does not correspond to a short phrase of one or more tags, a first field corresponding to one or more of the plurality of users is obtained; Retrieve the first field profile corresponding to the first field; A first summary corresponding to the first user interface session is generated based on a short phrase of a first tag, wherein the short phrase of the first tag is determined based on the first short phrase; and This causes the first summary to be displayed on the user interface.

3. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the second field corresponding to the first session type of the first user interface session; and Retrieve the second field profile corresponding to the second field.

4. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine a first role corresponding to one or more of the plurality of users; and Retrieve the second domain profile corresponding to the first role.

5. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the second user interface session corresponding to the first user interface session; Retrieve the second text string corresponding to the second user interface session; and The first context of the first short phrase is determined based on the second text string.

6. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the second user interface session corresponding to the first user interface session; and Determine the second domain profile corresponding to the second user interface session.

7. The method according to claim 2, wherein, Determining whether the first short phrase corresponds to a short phrase of the one or more tags further includes: Parse the second text string to detect the second short phrase; Determine whether the second short phrase corresponds to the first short phrase; and In response to determining that the second short phrase corresponds to the first short phrase, it is determined whether the second short phrase corresponds to a short phrase of the one or more tags.

8. The method according to claim 2, wherein, Determining whether the first short phrase corresponds to a short phrase of the one or more tags further includes: Parse the second text string to detect the context of the first short phrase; Generate a contextual short phrase based on the second text string and the first short phrase; and Determine whether the contextual short phrase corresponds to a short phrase of the one or more tags.

9. The method according to claim 2, wherein, Determining whether the first short phrase corresponds to a short phrase of the one or more tags further includes: Parse the second text string to detect the context of the first short phrase; Generate a contextual short phrase based on the second text string and the first short phrase; and Determine whether the contextual short phrase corresponds to a short phrase of the one or more tags.

10. The method according to claim 2, wherein, Determining whether the first short phrase corresponds to a short phrase of the one or more tags further includes: Determine the first relevance between the first short phrase and the first user interface session; Compare the first correlation with the threshold correlation; and Based on the first correlation and the threshold correlation, the first short phrase is compared with the short phrases of the one or more tags.

11. The method according to claim 2, wherein, The short phrase for determining the first tag for the first short phrase also includes: Update the short phrases of the one or more tags to include the short phrases of the first tag; and Assign the short phrase of the first tag to the first short phrase.

12. The method according to claim 2, wherein, Determining the first domain corresponding to one or more of the plurality of users further includes: Determine that a first user among one or more of the plurality of users corresponds to the first audio input; and The first user is determined to correspond to the first domain.

13. The method according to claim 2, wherein, The short phrase of the first tag is determined using a model based on the first short phrase, wherein the model is trained by the following operations: Receive the first set of parameter adjustments at the first frequency; and The second set of parameters is received at the second frequency.

14. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the first acronym corresponding to the first field profile; and Determine whether the first initial abbreviation corresponds to the first short phrase.

15. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the first category corresponding to the first domain profile; and The first classification method is used to determine the first context of the first short phrase.

16. The method according to claim 2, wherein, The short phrase of the first marker is also based on: Determine the first data storage location corresponding to the first domain profile; and A knowledge base for the model is generated based on the content from the first data storage location.

17. One or more non-transitory computer-readable media, including instructions that, when executed by one or more processors, cause operations including: Detect the first short phrase; In response to detecting the first short phrase, determine whether the first short phrase corresponds to one or more tagged short phrases; In response to determining that the first short phrase does not correspond to a short phrase of the one or more tags, a first field corresponding to one or more users among a plurality of users is determined; Retrieve the first field profile corresponding to the first field; A first summary corresponding to a user interface session is generated based on a short phrase of a first tag, wherein the short phrase of the first tag is determined based on a short phrase of the first tag for the first short phrase; and This causes the first summary to be displayed on the user interface.

18. One or more non-transitory computer-readable media according to claim 17, wherein, The short phrase for determining the first tag of the first short phrase further includes: Update the short phrases of the one or more tags to include the short phrases of the first tag; and Assign the short phrase of the first tag to the first short phrase.

19. One or more non-transitory computer-readable media according to claim 17, wherein, Determining the first domain corresponding to one or more of the plurality of users further includes: Determine that the first user among one or more of the plurality of users corresponds to the first audio input; and The first user is determined to correspond to the first domain.

20. One or more non-transitory computer-readable media according to claim 17, wherein, The short phrase of the first tag is determined using a model based on the first short phrase, wherein the model is trained by the following operations: Receive the first set of parameter adjustments at the first frequency; and The second set of parameters is received at the second frequency.

Images