User-Driven Semantic Persona Graphs Powered by GenAI

Introduction

Modern organizations increasingly rely on knowledge graphs to model complex relationships between business entities, risks, and controls. However, building these graphs traditionally requires painstaking manual effort or static questionnaires that often miss context and fail to engage users. In the cybersecurity domain, for example, an executive might be asked to fill out a 50-question survey to map their company’s risk profile – a process that is tedious and not tailored to the individual. There is a need for a more dynamic, user-friendly approach to personalized persona graph creation, where the user actively guides and verifies the knowledge captured about their context. Recent advancements in Generative AI (GenAI) and large language models (LLMs) offer a compelling solution: an interactive system that asks adaptive questions, builds a semantic graph of the user’s domain, and continuously refines that graph with user feedback. This white paper presents a GenAI-powered, user-driven workflow for creating rich persona-based knowledge graphs on demand, leveraging open-source tools (such as OSBot and MGraph-DB) in a serverless architecture. The approach transforms a traditionally static Q&A process into an engaging dialogue – one that not only populates a graph with relevant data points but also helps the user discover insights about their own domain.

Challenges of Static Questionnaires

Traditional approaches to gathering information for a knowledge graph often involve static forms or lengthy questionnaires. These suffer from several drawbacks:

One-Size-Fits-All Questions: A fixed questionnaire cannot adapt to each user’s context. Many questions may be irrelevant or fail to drill down on important details specific to that user’s business or role. This lack of personalization makes the process inefficient and tedious.
Context Switching: Users must answer questions without seeing the “big picture” of how their answers relate. They may not understand why a question is asked or how it connects to their situation, reducing engagement and the quality of input.
Limited Depth: Static forms can’t easily probe deeper based on a previous answer. If a user gives an intriguing response that opens a new line of inquiry, a preset survey won’t follow up – leading to lost opportunities to gather valuable information.
User Fatigue: Filling out dozens of questions in isolation is boring and time-consuming. Busy professionals (e.g. a CEO or CISO providing information about their company’s security posture) might abandon the process or provide minimal answers, undermining the whole effort.

The result is often a sparse or inaccurate knowledge graph that doesn’t truly capture the nuances of the user’s context. Clearly, a more flexible and engaging method is needed to elicit 50+ data points from a user in a way that feels natural and valuable to them. This is where GenAI can make a difference, by turning the interrogation into a conversation.

GenAI-Driven Interactive Workflow

Instead of a rigid questionnaire, we propose an interactive Q&A workflow orchestrated by an LLM. The process begins with an almost empty graph – perhaps just a single node representing the persona (e.g. “Business User” or a specific role in a company). From there, the system dynamically generates questions, one at a time, adapting to the user’s responses. Each answer the user provides is parsed (with AI assistance) into structured data that expands the graph with new nodes and edges. Crucially, the next questions are informed by the growing graph, allowing a personalized path of inquiry.

For example, the first question might be high-level: “What industry is your company in?” If the user answers “healthcare,” the graph gains a node for the healthcare sector. The LLM, armed with domain knowledge, can now tailor subsequent questions to healthcare-related risks or regulations. A next question might be “How many employees do you have and how large is your IT team?” If the user’s answer mentions that they use cloud services, that detail is added as a node (or attribute) in the graph (e.g. a node for “Cloud Infrastructure”). The following question can then dive deeper into cloud security concerns. In this manner, the interview dynamically branches into topics relevant to the user’s situation – much like a conversation with a human analyst, but powered by AI logic.

Under the hood, the LLM is effectively planning a dialogue to fulfill certain objectives (the “data points” needed). Rather than a predetermined list of 50 questions, we give the LLM a list of information targets and allow it to decide what to ask and in what order. This yields a personalized questionnaire that feels context-aware. If a user’s answer already contains several data points, the system recognizes those and skips redundant questions. In trials of this approach, we found that users often volunteer extra details in a single response, and the LLM can intelligently extract those and adjust the questioning accordingly. As Dinis Cruz noted in his experiments, sometimes “the user already provides a lot of answers… in one answer, so we can then just jump into it” – an adaptive flow that static forms simply cannot match.

Throughout this process, the knowledge graph is incrementally built. Think of the graph as a living map of the user’s business context: it might include nodes for the company, its industry, key assets, threats, compliance obligations, and so forth, all linked in meaningful ways. By the end of the Q&A session, the graph might be richly populated with dozens of interconnected nodes representing the landscape of that persona (for a cybersecurity executive, this could map out their organization’s security posture, concerns, and risk areas). The power of this approach is that the graph is constructed with the user rather than behind the scenes – making it far more likely to be accurate and comprehensive. And because it’s guided by GenAI, we avoid overwhelming the user; at each step, they answer a focused question in natural language, which is both more engaging and more intuitive than filling a spreadsheet.

Notably, generative AI doesn’t just ask the questions – it also helps interpret the answers. The free-form text responses from the user are run through the LLM (or associated NLP tools) to extract the key facts or entities that become part of the graph. This use of AI for entity extraction is essential for scalability. As Dinis Cruz points out when describing a related news feed project, “we use LLMs here because this is the only scalable and practical way to extract entities (i.e. Semantic Knowledge Graphs) from some text”. In our scenario, the “text” is the user’s answer, and the entities are the semantic pieces of knowledge (like “uses AWS cloud” or “concerned about ransomware”) that we add to their persona graph. Without LLMs, translating arbitrary user input into a structured graph would require brittle manual rules; with GenAI, the system can flexibly understand and categorize the user’s statements.

A cornerstone of our approach is incorporating human-in-the-loop feedback. Rather than solely relying on the user’s initial answers, the system periodically reflects back its understanding and asks the user to validate or correct it. This could be as simple as: “It sounds like you are most concerned about data breaches affecting customer information – is that correct?” followed by a Yes/No or multiple-choice confirmation. The rationale is that it’s often easier for users to verify information than to come up with it from scratch. By confirming (“Yes, that’s correct”) or clarifying (“Actually, my bigger worry is insider threats leading to data leaks”), the user helps refine the graph’s accuracy.

This feedback loop turns the graph-building into a collaborative process. The AI may infer or suggest a relationship, but the user is the ultimate arbiter of truth for their scenario. According to Dinis Cruz, such human-in-the-loop systems are vital because “graphs should evolve and get better the more they’re used… we should create feedback systems that allow constant validation and refinement”. Each interaction with the user is an opportunity to tune the knowledge graph to better reflect reality. Over time, this yields what Cruz calls “living knowledge structures that actually represent reality” – in contrast to static diagrams that were drawn once and quickly become outdated. In practice, after a series of Q&As and confirmations, the persona graph becomes a validated model of the user’s context, one that both the system and the user trust.

From a user experience (UX) perspective, this method is surprisingly engaging. Instead of passively filling forms, the user is engaged in a dialogue and even a bit of exploration. The system might visualize parts of the graph (for instance, showing a risk map or a summary of concerns) and ask “Do you agree that these are your top threats?” Seeing a visual or list generated from their own inputs can spark insight – the user might respond, “I realize now that third-party risk should be on that list too,” prompting further questions about supply chain or vendor security. This interplay ensures the user is learning and reflecting throughout the process. In fact, one design goal is for the user to gain value (new understanding of their situation) even before any final output is produced. By asking thought-provoking questions (e.g. “What would happen if your main database became corrupted?” or “How would a week-long system outage impact your customers?”), the system surfaces considerations the user may not have pondered. The process thus doubles as a mini risk assessment workshop guided by AI. Many users report this to be “an interesting experience… intellectually challenging and interesting” rather than a chore, especially as the questions are tuned to their knowledge level, role, and industry.

To support this adaptive UX, we leverage modern no-code/low-code and dynamic UI generation techniques. The idea is to present the graph and questions in a user-friendly manner, potentially with custom visualizations generated on the fly. For instance, if the user’s role is non-technical (say a Board member), the interface can use plain language and business-oriented visuals (e.g. high-level risk heatmaps) instead of technical jargon. If the user is more technical (like a CTO), the questions and visuals can be more granular. By generating the interface dynamically – something made easier by “vibe coding” frameworks – the system can tailor the experience in real-time to each persona. Ultimately, confirming details via a slick UI (clicking yes/no, dragging a slider to indicate level of concern, etc.) can be far more pleasant than typing out every answer. It also provides variety in the interaction, which keeps users engaged over the span of dozens of questions. The dynamic UI becomes another feedback mechanism: it shows the user what the AI has compiled so far (in an easily digestible form) and asks if it’s correct or needs adjustment. This aligns with Cruz’s philosophy that “graph designers should think like UX designers… the information flow needs to be human-centered and intuitive”. By treating the knowledge graph not just as data but as a user-facing product, we ensure that the end-user remains at the center of the creation process.

Architecture and Key Building Blocks

Implementing this kind of user-driven graph system is now feasible thanks to serverless computing, semantic graph databases, and GenAI integration. Our reference implementation uses an on-demand, serverless architecture – meaning it can scale to handle many concurrent sessions and incurs no cost when idle. Whenever a user begins a Q&A session, lightweight cloud functions spin up to handle the dialogue logic and graph updates, then spin down when done. This makes the solution cost-efficient and highly scalable for potentially thousands of personalized graph-building sessions.

A few key open-source components (developed by Dinis Cruz and collaborators) form the backbone of the system:

OSBot-FastAPI: This is an open-source package that simplifies creating FastAPI services for serverless deployments. We use it to define the API endpoints (for example, one endpoint might handle retrieving the next AI-generated question, another to submit an answer). OSBot-FastAPI abstracts away much boilerplate. As Cruz describes, “I’m using the OSBot-Fast-API open source package, which makes it super easy to create these serverless functions (easier than using FastAPI directly)”. With this, our entire Q&A workflow runs as a set of serverless functions (in AWS Lambda, for instance), triggered by user interactions and GenAI requests. The result is a highly modular and cloud-native service.
OSBot-Utils (Flows/Tasks system): Behind the scenes, orchestrating a multi-step dialogue with an LLM and a user involves managing state and sequence (ask question → get answer → update graph → repeat). The OSBot-Utils library provides a flows and tasks framework (inspired by Prefect) to coordinate these steps seamlessly. Each “question-response-update” cycle can be treated as a task, and the whole interview as a flow. This approach proved effective in similar projects; in fact, the flows technology used in MyFeeds.ai (for processing news articles) “is part of [the] OSBot-Utils open source package… inspired by and compatible with the super powerful Prefect open source technology”. In our case, OSBot-Utils helps manage the conversation state and ensures reliability (e.g., we can retry a step if an LLM call fails, or parallelize certain background tasks like fetching external data).
MGraph-DB (Memory-First Graph Database): All data captured from the user is stored in a semantic graph database optimized for this scenario. MGraph-DB (also referred to as MGraph-AI in newer versions) is a memory-first graph database designed specifically for AI and serverless contexts. Unlike traditional graph databases, it is lightweight and can run efficiently within a serverless function’s ephemeral environment. It keeps the evolving graph in memory for fast operations and persists it as JSON to cloud storage for durability. This design gives us the best of both worlds: speed and low latency during the interactive session, and persistence for later analysis or reuse of the graph. Importantly, MGraph-DB was created to meet needs exactly like ours. Cruz found that existing graph databases were “too heavy, too complex to deploy, or just didn't fit well” for serverless AI workloads, so he built MGraph to support: (a) serverless execution (zero cost when idle), (b) GenAI workloads that need rapid graph updates (e.g. real-time retrieval of info for an LLM, often called “Graph RAG”), (c) semantic web flexibility – the ability to store loosely structured, evolving schemas, and (d) using simple file storage (JSON) as the backing store. Our persona graph, which grows organically as the user answers questions, is an ideal use case for this. We benefit from MGraph-DB’s high-performance in-memory operations and its support for rich attributes on nodes/edges (to capture details like “importance level” of a risk, or timestamp of when the data was confirmed). Moreover, MGraph’s built-in version control and diff capabilities allow us to track changes to the graph over time – a useful feature if the user comes back later to update their profile, or if multiple sessions are combined.
LLM Integration: At the heart of the system is the large language model (such as OpenAI’s GPT-4 or similar) that generates questions and interprets answers. This is not a standalone library but rather an integration: OSBot-LLMs (an extension in the OSBot ecosystem) or direct API calls to an AI service. The LLM is prompted with context from the current graph and the list of remaining information needs, and it outputs the next best question to ask. After the user responds, another LLM call helps convert that free text into structured graph updates (e.g., identifying that “ransomware” was mentioned as a concern, linking it to a “Threat: Ransomware” node). The system can also use smaller AI models for certain tasks (for example, using an NLP classifier to detect sentiment or priority in the user’s answer, if needed). Caching is employed to avoid repetitive calls and to speed up entity extraction. As mentioned earlier, using LLMs is crucial because they can understand context and language nuances that traditional parsers cannot, enabling the graph to capture subtleties of the user’s input.
Serverless Deployment: All components are designed to be deployed in a cloud-native fashion. The FastAPI routes (via OSBot-FastAPI) are packaged into serverless functions. MGraph-DB, being file-based, persists its JSON files in cloud object storage (like Amazon S3 or Azure Blob Storage) which aligns with the stateless nature of serverless computing. This means we achieve an on-demand semantic graph service – when a user starts a session, the functions load the necessary context (possibly pre-filling some data as we’ll discuss next), conduct the interactive dialogue, save the results, and then spin down, not consuming resources until needed again. This elasticity is important for a multi-tenant system serving many users, and it also allows us to integrate with event-driven workflows (for instance, triggering an update if new external data about the company becomes available). As an added benefit, by using open-source and standard technologies under the hood, the solution avoids vendor lock-in and remains extensible. Dinis Cruz himself has successfully used this stack (serverless + FastAPI + MGraph) in production for other projects, noting how it enabled maintaining “multiple interconnected Semantic Knowledge Graphs that serve different stakeholders… without forcing anyone to learn a standardized language” while GenAI acts as “the translator, the connector, and the catalyst for continuous improvement”. In other words, the architecture empowers flexible knowledge sharing: each user (or stakeholder group) gets a graph tailored to their perspective, and AI bridges those perspectives when needed – all running efficiently at scale.

Pre-Population and External Data Integration

A particularly powerful enhancement to the workflow is pre-populating the graph using external data before or during the user session. Often, a lot of information about a company or individual is available from public or internal sources. Rather than ask the user to input facts that could be auto-fetched, the system can do a preparatory analysis. For example, if the user provides their company name and role, we could automatically pull basic company information (industry, size, recent news) from public databases or APIs. In a cybersecurity context, one could even retrieve threat intelligence or known breach data related to that industry or the specific company. The idea is to gather as much as possible upfront, so that the AI can ask more informed and specific questions, and so the user can spend time on insights rather than simple facts.

Imagine the system starts a session by saying: “Before we begin, I’ve gathered some information about your company. I found that you have approximately 500 employees, use Office 365, and were mentioned in a recent data privacy report. I’ve added these to your profile – could you confirm if this is correct?” A user seeing this is likely to be impressed (and perhaps a bit alarmed) by what’s already known – but it immediately establishes relevance. They can correct any inaccuracies (“Actually we have 600 employees, not 500”) and then we proceed with deeper questions. This approach not only saves the user time, but also sets the stage for a more meaningful dialogue: we don’t waste questions on basics, and we can dive straight into issues that matter. It also educates the user about their external footprint, which in security is often an eye-opener (“You mean our company is listed on a data privacy report publicly?”).

Technically, integrating such data might involve microservices or third-party APIs that are invoked in the flow (this can be done asynchronously while the user is answering early questions). Thanks to the modular design with OSBot flows, adding a step to call, say, a company info API or a security ratings service is straightforward. If the user consents and the value is worth it, premium data sources could be tapped (for example, a service that provides a list of a company’s exposed databases or leaked credentials). The key is to always loop the user in – we never blindly trust external data without user confirmation. The graph may be pre-populated with guesses or findings, but the user will validate them. This keeps the knowledge graph accurate and personalized. It also addresses privacy concerns, since the user remains in control of what data is accepted into their persona profile.

By leveraging external knowledge, the system effectively accelerates the conversation. In some cases, we might achieve 80% of the graph fill-out with minimal questioning, focusing the live Q&A on the remaining 20% that is truly subjective or nuanced. This combination of automated research + interactive interview is a game-changer in user-driven graph creation, enabled by the fact that GenAI can interpret both the external data and the user’s inputs in a unified way. Just a few years ago, orchestrating such a process (across multiple data sources and adaptively questioning the user) would have been deemed “ridiculously expensive to create”, as Cruz notes, due to the complexity of maintaining context and dialogue flow. But today’s AI and graph technology make it feasible, even elegant. We can dynamically generate not just questions but an entire UI and data pipeline tailored to an individual – essentially on the fly.

Applications and Use Cases

While the genesis of this approach was in the cybersecurity realm (specifically tailoring content for boardroom executives and security officers), user-driven persona graphs have broad applicability across industries. Below we outline a few key use cases, highlighting both cybersecurity examples and wider applications:

Cybersecurity Risk Profiling (Executive Persona): An immediate use case is the one discussed throughout this paper – capturing a company’s security profile by interviewing an executive (CEO, CISO, CTO, etc.). The resulting graph links business context (crown jewel assets, critical processes) with threats (like ransomware, insider threat), vulnerabilities, and controls or compliance requirements (e.g. mapping to ISO 27001 clauses or NIST CSF categories). This personalized graph can then be used to generate executive reports, prioritized action plans, or even tailored security training for that persona. It essentially automates and enhances what a consulting assessment would do, but in an ongoing, interactive manner. As a bonus, because the graph is semantic, it can be queried to provide just-in-time answers – for instance, if a board member asks “How prepared are we for X?”, the system can traverse the graph and formulate a data-driven answer. This use case was a driver for The Cyber Boardroom project, and indeed Cruz reports that having every risk and control node ultimately trace up to business objectives (and the CEO’s concerns) created “natural organisational principles without forcing rigid standardisation” in their security knowledge management. In other words, each company’s graph can be unique, yet still comparable via common touchpoints (like shared risk definitions), which GenAI can translate between.
Personalized News and Content Feeds: A very different domain where this approach shines is personalized content curation. The MyFeeds.ai project has demonstrated how semantic graphs can be built for personas like “Tech CEO” or “Security Analyst” to tailor news feeds. In that system, various personas have their own interest profiles and taxonomies, and content (news articles) are ingested and tagged into a graph of topics. A dynamic process (powered by flows and MGraph) then generates a custom feed for each persona, highlighting new articles relevant to them and even generating summaries. While the user-driven aspect in that case is slightly different (based on roles rather than an interview), the concept can be extended: imagine a user answering a few questions about their interests, and a graph being built that represents their knowledge domains. The system can then fetch and filter content that matches that graph. Over time, as the user interacts (clicks an article, gives feedback “more of this, less of that”), the graph updates – very similar to how our Q&A session updates the security profile. The end result is a constantly learning recommendation system. Indeed, the combination of GenAI and knowledge graphs in MyFeeds allowed creating “personalised content for different personas (CEO, CISO, CTO, Board Members)” through a serverless workflow that downloads sources, transforms them into structured graphs, and visualises trends, leveraging OSBot-FastAPI and MGraph-DB to ensure data provenance. This showcases that the technology and approach can personalize any information domain, not just security.
Corporate Compliance and Auditing: Beyond cybersecurity, many industries require companies to report on compliance (be it privacy, finance, environmental). A user-driven graph approach could help a compliance officer map their organization’s status against a framework. Instead of filling out a static compliance checklist, an AI system could interview them: “Do you store personal data of EU citizens? How many records? Do you have encryption at rest?” etc., building a graph that links the company’s practices to regulatory requirements. The compliance officer could then visualize which requirements are unmet or which risks are highest. The interactive nature ensures that if a particular regulation doesn’t apply, the AI won’t waste time on it, focusing only on relevant sections. And if the officer is unsure about a question, the system can even provide definitions or examples on the fly (leveraging LLM’s ability to explain concepts). This use case again benefits from the graph being a living artifact – as regulations change or the business changes, the graph can be updated through new Q&A sessions or data imports, maintaining an up-to-date compliance posture.
Customer Onboarding and Support Personalization: For customer-facing businesses, understanding each customer’s needs quickly is key. A user-driven graph could be used during onboarding of a new client – an AI-guided interview builds a profile of the client’s context, goals, and constraints. For instance, in a B2B software company, when a new client signs up, instead of making them fill a long setup form, an AI agent could ask, “What are you hoping to achieve with our software? What other systems do you use? Describe your team’s skill level,” etc. The resulting graph helps configure the product for them and guide the customer success team on how best to support that client. In ongoing support, if a client has an issue, the support agent (or AI assistant) can query the customer’s knowledge graph to get instant context. This reduces repetitive questions and speeds up resolution with personalized answers. Essentially, it’s the idea of a personal knowledge base for each user or client, built collaboratively.
Education and Training: Personalized learning is another arena – imagine an AI tutor that builds a knowledge graph of a student’s understanding. Through Q&A, it determines what the student knows, where the gaps are, and what learning style works best. The graph might include nodes for concepts the student has mastered and those they struggle with. The system can then adapt the curriculum in real-time, focusing on areas that need reinforcement and skipping those already understood. Periodic feedback from the student (like confirming if they feel confident about a topic) refines the graph. Over a course, this graph-driven approach could provide a highly tailored learning experience and even output a visualization of the student’s progress.

These examples only scratch the surface. In general, any domain where context matters and one size doesn’t fit all is a candidate for GenAI-driven graph personalization. The common thread is that by combining human input and AI, we create a self-improving knowledge structure that’s far more aligned to the user’s reality than a generic template. Organizations can maintain multiple such graphs for different perspectives (executive, technical, customer, etc.) and use AI to bridge between them when needed. For instance, a technical risk graph and a business risk graph can be linked via common nodes or relationships, enabling translation between tech-speak and business-speak – something GenAI is very good at. As Cruz notes, this avoids forcing a single rigid ontology on everyone; instead “each team/culture/role [can] develop their natural terminology” while AI helps “create connections between related concepts across [these] ontologies”. The result is a federation of graphs, or an “ontology of ontologies,” where personalization and standardization find a balance.

Benefits and Conclusion

The user-driven persona graph approach offers significant benefits over traditional methods of knowledge capture and personalization:

High Engagement, Less Fatigue: By turning the process into an interactive dialogue, users remain engaged. They see immediate reflections of their input (through follow-up questions or visual feedback), which motivates them to continue. The variety of question types and the conversational tone make it a far more pleasant experience than slogging through forms.
Contextual Depth: The adaptive nature of the AI questioning ensures that we gather depth where it matters. If a particular area is very relevant to the user (e.g. cloud security for a tech company), the LLM will naturally focus more questions there. Conversely, if something is not applicable, it gets skipped quickly. This yields a rich graph that truly captures important nuances, rather than a shallow one-size-fits-all dataset.
Accuracy and Trustworthiness: With constant user validation (human-in-the-loop), the information in the graph is vetted at each step. Users are more likely to trust the final output (be it a risk report, a set of recommendations, or an analysis) because they were involved in correcting and confirming the data. The graph isn’t a black box; it’s a mirror of what they agreed to. This is crucial if the graph is used for decision-making. As one commenter on Cruz’s research noted, the shift to dynamic, self-evolving graphs is “a compelling opportunity not only to map knowledge but also to enhance real-time decision-making”, and the key question becomes maintaining transparency and trust as these systems scale. Our approach addresses that by keeping the user in the loop.
Living Knowledge Base: The output of the process – the semantic persona graph – is not a static snapshot. It can be revisited and updated continuously. Each interaction with the user (or even automated updates via new data) makes the graph more accurate over time. In effect, the knowledge base evolves with the business or person it represents. This is invaluable in fast-changing fields like cybersecurity, where yesterday’s top threat might be replaced by a new one tomorrow. Instead of doing a full reassessment from scratch, the system can prompt the user for just the delta (“A new type of ransomware has emerged; do you use technology X that is vulnerable to it?”) and update the graph accordingly. The knowledge thus remains current and actionable.
Scalability and Consistency: By leveraging GenAI and automation, what used to require a team of consultants or lengthy manual research can be done quickly and at scale. Many users can go through their own personalized interview simultaneously, each receiving the same attentive experience. The AI ensures a level of consistency in what data is collected (we won’t accidentally forget to cover a crucial topic) while still customizing to individual contexts. This combination of consistency and personalization is hard to achieve with purely human-led processes. Moreover, the serverless and open-source foundation means the solution can be scaled within an organization or offered as a service with relatively low operational overhead.

In conclusion, user-driven graph creation powered by LLMs represents a paradigm shift in how we capture and organize knowledge. We move from static, top-down taxonomy imposition to an organic, bottom-up growth of graphs that mirror the user’s mental model and real-world situation. The synergy between human expertise and AI assistance yields a system that adapts continuously, learns from each interaction, and bridges diverse viewpoints into a coherent whole. Early implementations in cybersecurity and personalized content have validated the effectiveness of this approach, turning what was once an overwhelming data collection exercise into a streamlined, even enjoyable, experience. The phrase “self-improving knowledge graph” truly comes to life here – the more the graph is used and touched by human insight, the more valuable it becomes.

As we stand at this intersection of GenAI and knowledge management, the possibilities seem boundless. We can finally escape the “perfect taxonomy” trap of traditional KM, as our AI-enhanced graphs can flex and evolve without constant re-engineering. Looking ahead, as LLMs grow more powerful and our design patterns for human-AI collaboration mature, we can expect even more seamless and intelligent knowledge ecosystems. These will not only capture information, but also context, rationale, and connections that drive better decision-making. In essence, by fusing user-driven inputs with machine-driven scalability, we are creating a future where knowledge becomes living – continuously refined by those who use it, and readily translated across domains by AI. The work by Dinis Cruz and others in pioneering serverless semantic graphs with GenAI bridges has shown that we’re “only scratching the surface of what’s possible”. The journey ahead is exciting, and it promises knowledge solutions that are more resilient, personalised, and insightful than ever before.

Sources: Dinis Cruz’s research and open-source projects (OSBot, MGraph-DB, MyFeeds.ai, The Cyber Boardroom), along with the collaborative analysis by ChatGPT Deep Research.