<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Agentic Guru - Medium]]></title>
        <description><![CDATA[Agentic Guru is a melting pot where DevOps, coding, data science, &amp; AI converge. We bring together practical examples, Crazy ideas, and futuristic thoughts to explore how these fields are reshaping the tech landscape. - Medium]]></description>
        <link>https://medium.com/data-scientists-from-future?source=rss----2fbb407b05fd---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Agentic Guru - Medium</title>
            <link>https://medium.com/data-scientists-from-future?source=rss----2fbb407b05fd---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 08:58:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/data-scientists-from-future" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Rules as Code, Not Prose: Letting an Ontology Compute Its Own Rules in a Browser Tab]]></title>
            <link>https://medium.com/data-scientists-from-future/rules-as-code-not-prose-letting-an-ontology-compute-its-own-rules-in-a-browser-tab-b7e26f858c57?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/b7e26f858c57</guid>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 18:21:59 GMT</pubDate>
            <atom:updated>2026-10-28T18:23:08.398Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Eoie4_trNPtiAz9F.png" /></figure><p>Ontologies are back in fashion, mostly as a source for language models. A team models its domain as classes, properties and facts, then hands that model to an assistant so it can answer questions with more than document snippets. The facts usually make the trip intact. The rules often don’t.</p><p>A rule is the part of an ontology that produces new facts from old ones. “If A depends on B and B depends on C, then A depends on C.” “A package is blocked if it is exposed to an advisory that is critical and open.” In many current setups those rules are written as English sentences and placed in the prompt next to the facts. The language model is then expected to apply them: to follow every chain to the end, to check every clause of every condition, and to do it the same way each time someone asks.</p><p>That asks a model to be an inference engine. It can look like one on easy cases. It fails on exactly the cases rules exist for: long chains, conditions with more than one clause, and counts over sets it had to build itself. It also fails differently from run to run, so a team testing the assistant once may never see the problem.</p><p>There is an older way to state a rule. OWL has had owl:TransitiveProperty since 2004 and property chains since OWL 2 in 2009. Rules with joins are what SWRL and Datalog were built for. A rule written that way is not read; it is run. A reasoner applies it to every fact, follows every chain to the end and checks every clause, and gives the same result every time.</p><p>OntoCompute puts the two approaches side by side in a browser tab, on the same facts and the same questions, so you can watch the difference instead of taking it on trust.</p><blockquote><em>Inspired by Miodrag Cekikj, </em><a href="https://medium.com/p/56aea5e1549f"><em>“Give the Knowledge Layer Something to Compute: Foundry IQ and the Fabric IQ Ontology, Measured”</em></a><em> pubished in AI Advances</em></blockquote><h3>A small world with three rules</h3><p>The page holds an invented open-source package ecosystem. It is small enough to check by hand and deep enough to need real inference: 14 packages, dependency chains up to four hops long, and five security advisories, each with a severity and a status.</p><p>A few of the stated facts:</p><ul><li>harbor-cli depends directly on harbor-core and nimbus-log.</li><li>harbor-core depends directly on cobweb-http and ferrous-json.</li><li>cobweb-http depends directly on skein and tinyhash; skein depends directly on brindle.</li><li>otter-ui depends on pallet, which depends on lattice, then mothball, then quill.</li><li>Advisory ADV-101 is on brindle. It is critical and open.</li><li>Advisory ADV-104 is on quill. It is critical but patched.</li></ul><p>Three rules sit on top of the facts:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UefG-Je7CfldirlHmLxJTQ.png" /></figure><p>Each rule tests something different. Rule 1 is a chain: to know everything harbor-cli depends on, you have to walk four hops down to brindle. Rule 2 is a chain followed by one more step: walk the dependencies, then collect the advisories on everything you reached. Rule 3 is a join: two conditions on the same advisory, both of which must hold. An advisory that is critical but patched doesn’t count, and neither does one that is open but low severity.</p><p>The world is built so that these rules have consequences. kestrel is release-blocked, but only through skein to brindle, two hops away. otter-ui is exposed to a critical advisory, ADV-104 on quill, four hops down, but that advisory is patched, so otter-ui is not blocked. A shortcut in any rule gives a different answer.</p><h3>Twelve questions, three ways to answer</h3><p>The page asks twelve questions, each tagged by shape:</p><ul><li>Direct lookup: “Which packages does harbor-core depend on directly?”</li><li>Chain: yes/no (“Does otter-ui depend on quill?”), list (“Which packages does harbor-cli depend on?”), reverse (“Which packages depend on brindle?”) and count (“How many packages depend on tinyhash?”).</li><li>Property chain: “Which advisories is pallet exposed to?”</li><li>Join: “Which packages are release-blocked?”, “Is otter-ui release-blocked?”, “Is kestrel release-blocked?”</li><li>Not modeled: “Who maintains quill?” and “When was ADV-105 published?” The ontology has no maintainers and no dates, so the right answer is to say so.</li></ul><p>Every question is answered three ways.</p><p>Prose. The facts and the three English rules go into the prompt, followed by the question. The model works out the answer and ends with a line that starts ANSWER:. This is the rules-in-plain-words approach.</p><p>Compiled. The model never sees the rules. It gets the schema (the property names, the classes, the package names) and a few examples, and its only job is to turn the question into a one-line query such as SELECT ?x WHERE ?x a ReleaseBlocked. A reasoner runs that query over every fact the rules imply.</p><p>Reasoner only. The same reasoner runs a hand-written query, with no model at all. This is the best compiled mode can do, and it is where the right answers come from. The test suite pins each of them against an answer worked out by hand.</p><p>The page can ask each question several times in each mode, each run a fresh conversation. For every question it shows how often the answer was right, how many different answers came back, and how long a run took.</p><p>Everything happens in the tab. The reasoner is a few hundred lines of TypeScript. The model runs on your own GPU through WebLLM. Nothing is sent to a server.</p><h3>How the compiled side works</h3><p>The ontology is a plain Turtle file. When the page loads, each OWL axiom is compiled into a rule of one simple form: a few triple patterns in, one triple out.</p><ul><li>TransitiveProperty on dependsOn becomes: if ?a dependsOn ?b and ?b dependsOn ?c, then ?a dependsOn ?c.</li><li>subPropertyOf becomes: if ?a directlyDependsOn ?b, then ?a dependsOn ?b.</li><li>The property chain becomes: if ?p dependsOn ?x and ?x hasAdvisory ?a, then ?p exposedTo ?a.</li><li>The join rule in the rules file already has this form.</li></ul><p>subClassOf, inverseOf and SymmetricProperty compile the same way, so adding a new kind of axiom means writing one small translation.</p><p>The reasoner then applies every rule to every fact, adds whatever is new, and repeats until a pass adds nothing. In this world that produces 54 new triples in four passes and takes a few milliseconds. That is the slow, simple way to do it. It is still far faster than anything else in the loop.</p><p>While it works, the reasoner records how it first derived each triple. So every answer comes with a proof that goes all the way down to stated facts. Ask why kestrel is release-blocked and the page shows:</p><ul><li>kestrel is exposed to ADV-101, because kestrel depends on brindle and brindle has advisory ADV-101.</li><li>kestrel depends on brindle, because kestrel depends directly on skein and skein depends directly on brindle.</li><li>ADV-101 is critical and open (stated).</li><li>So by rule 3, kestrel is release-blocked.</li></ul><p>The model’s query language is deliberately small. SELECT returns a list, ASK returns yes or no, COUNT returns a number, and patterns can be joined with a dot. One more form matters a lot: NOT_IN_SCHEMA. If the question needs something the ontology doesn&#39;t have, the model can say so, and the result is a typed answer, NOT_IN_SCHEMA maintainer. The page also checks every query against the schema. A query that uses a property, class or package that doesn&#39;t exist becomes the same typed answer instead of an error or an empty list.</p><p>That matters for whoever sits above the ontology. “Not modeled” is useful information: it tells the caller to try the documents instead. It should be a result the caller can act on, not an exception.</p><h3>Naming the missing step</h3><p>When an answer is wrong, it helps to know why. OntoCompute works this out the same way it works out right answers: by running the reasoner.</p><p>For each question, the page builds a few broken versions of the world. In one, dependencies aren’t transitive, so only direct dependencies count. In another, the join rule ignores the advisory’s status. In a third, it ignores severity. It then runs the correct query on each broken world. Those results are the answers you get when a rule is applied halfway.</p><p>If a wrong run matches one of them, the page labels it: <em>stopped at direct dependencies</em>, <em>dropped the clause “status is open”</em>, <em>dropped the clause “severity is critical”</em>. A wrong answer stops being just wrong and becomes a specific step that was skipped. That is far more useful when deciding whether a fix belongs in the prompt, the model or the rules.</p><h3>The experiment</h3><p>I ran all twelve questions five times each, in both prose and compiled mode, at temperature 0.7, on two models from the same family: Qwen2.5–3B and Qwen2.5–7B, both 4-bit quantised and running in Chrome on a laptop with an integrated Intel GPU. That is 120 runs per model and 240 in all. Each run is a fresh conversation, so nothing carries over from one run to the next.</p><p>Temperature 0.7 is a typical setting for an assistant. A lower temperature would reduce the variety of answers, but it wouldn’t make a wrong rule right.</p><h3>What it showed</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*VGdynXbsL9pY3eDhUk-mBg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_SncEu9SKTxV6AyP.png" /></figure><p>Per question, for Qwen2.5–7B (right out of five):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/845/1*2RzbM0BgKkRP7zToXi0zfg.png" /></figure><p>Grouped by shape, 7B prose got direct lookups and not-modeled questions right every time, chains 40% of the time, joins 47%, and the property chain never. Compiled mode got every shape right every time.</p><p>The larger model barely moved prose mode, from 50% to 53%. It moved compiled mode from 65% to 100%. Applying English rules is the hard part, and it stayed hard. Turning a question into a query is the easy part, and the larger model did it without a single mistake.</p><p>Speed was about the same in both modes for each model: around 13 seconds a run for 3B and 30 seconds for 7B. Almost all of that is the model reading its prompt. The reasoner takes under 4 milliseconds.</p><h3>What the wrong answers look like</h3><p>The totals tell you that prose mode is unreliable. The individual runs tell you how.</p><p>Consistent is not the same as correct. On “which packages are release-blocked?” the 7B model gave the same wrong list, harbor-cli and otter-ui, in all five runs. The right answer is five packages, and otter-ui isn’t one of them. On “how many packages depend on tinyhash?” it said 3 in all five runs; the answer is 4. A common way to test an assistant is to ask the same question several times and check that the answers agree. These answers agree perfectly and are wrong. Only an answer that is computed catches that.</p><p>Long chains get cut short. On “does otter-ui depend on quill?”, four of the five prose runs said no. The page labelled each one <em>stopped at direct dependencies</em>. quill is four hops away, through pallet, lattice and mothball, and the model didn’t walk that far. On “is kestrel release-blocked?”, two runs said no for the same reason: the advisory is on brindle, two hops below kestrel. Prose mode handled one hop well. Each extra hop was another chance to stop early.</p><p>Clauses get dropped. On “is otter-ui release-blocked?”, one prose run said yes. otter-ui is exposed to ADV-104, which is critical, but it’s patched. That run matches the answer you get when the “status is open” clause is ignored. The join is the rule people most often write as a single English sentence, and it’s the one most easily read halfway.</p><p>Property chains were never right. “Which advisories is pallet exposed to?” needs a walk down the chain followed by a lookup at every stop. Neither model got it right in prose in any of ten runs. The answers mixed advisories on the wrong packages with advisories on the right ones, and one run listed a package name as if it were an advisory.</p><p>Compiled failures are visible. The 3B model’s compiled mistakes were all translation mistakes. It misspelled a package name. It wrote SPARQL-style FILTER and UNION clauses that the query language doesn’t accept. It invented a “publishedOn” property. It turned “who maintains quill?” into “is quill release-blocked?”. Every one of these is a one-line query you can read and see is wrong, and most of them produced no answer rather than a confident wrong one. A wrong prose answer is just a wrong list, with nothing to inspect except a long chain of reasoning.</p><p>To be fair to prose mode, there was one place where it did better. The 3B model said “not modeled” in prose for both not-modeled questions every time, but managed it through a query only 2 times in 10. A small model given a query language tends to write a query whether or not one makes sense. The 7B model had no such trouble.</p><h3>What this does and doesn’t show</h3><p>These are small models on a laptop, not the large hosted models teams use in production. A larger model will apply English rules more reliably, and a model that is allowed to reason at length may get further down a chain. The world is invented and small, and twelve questions in five runs each is a demonstration, not a benchmark.</p><p>What doesn’t depend on the model is the shape of the trade. In prose mode, every part of the answer is up to the model: reading the facts, following the chains, checking the clauses, counting the result. Any of those can slip, and none of them can be inspected except by reading its reasoning. In compiled mode the model’s job shrinks to one translation. Everything after that is done by code that can’t drop a clause, can’t stop a chain early and has no randomness of its own. Once the query is written, the answer is fixed, and the query itself is short enough to check.</p><p>That also changes what it takes to improve the system. To make prose mode better, you need a better model or a better prompt, and you find out whether it worked by running everything again many times. To make compiled mode better, you improve translation, which is a narrower task with a clear right answer that is easy to test.</p><h3>When to use which</h3><p>Not every rule fits an axiom, and not every question needs a reasoner. A rough guide:</p><ul><li>Use an axiom for anything with a fixed logical shape: transitivity, inheritance between classes, inverse properties, property chains. These are cheap to state in OWL and reasoners handle them well.</li><li>Use a rules engine for conditions that combine several facts, like the join here. Datalog and SWRL rules are short and easy to read once you have seen a few.</li><li>Leave it in prose when the rule needs judgement rather than logic: “prefer a well-maintained package”, “flag anything that looks unusual”. A reasoner can’t help there, and a language model can.</li><li>Make “not modeled” a result. Whatever sits above the ontology should get a typed answer it can route on, not an error.</li></ul><p>The pattern that comes out of this is a division of labour. The language model reads the person’s question and writes a query. The reasoner does the chaining, the checking and the counting. The answer comes back with a proof, and the query that produced it is there to read.</p><h3>Why this is useful</h3><ul><li>For anyone building on an ontology: if a rule can be written as an axiom, write it as an axiom. Use transitivity, property chains and a rules engine for joins. Let the language model turn a person’s question into a query, and let the reasoner do the counting and the chaining.</li><li>For anyone evaluating a knowledge layer: ask each question more than once, and also check the answers against computed ones. Repeated runs show whether an answer is stable. Only a computed answer shows whether it is right.</li><li>For anyone designing the “I don’t know” path: make “not modeled” a typed result, so the layer above can send the question to documents instead of failing.</li><li>For teaching: the page shows each rule in English next to its OWL form, draws the inferred facts on the dependency graph, and gives a proof for every answer. It shows what “the ontology computes it” means.</li></ul><h3>Try it</h3><ul><li>Live: <a href="https://vishalmysore.github.io/ontoCompute/">https://vishalmysore.github.io/ontoCompute/</a></li><li>Code: <a href="https://github.com/vishalmysore/ontoCompute">https://github.com/vishalmysore/ontoCompute</a></li></ul><p>Pick a model, choose how many runs per question, and press Run every question, or select one row and run just that question. You can also type your own question and see both modes answer it. The reasoner column, the proofs and the diagram work even in a browser without WebGPU. Results are measured in your browser and depend on the model, the temperature and your GPU. The raw results for both models used here are in the repository under docs/results/.</p><h3>Disclaimer</h3><p>OntoCompute is a personal, independent project. It isn’t affiliated with, endorsed by or connected to Miodrag Cekikj, Microsoft, or the makers of the models and libraries it uses; credit for the measurements that prompted it goes to <a href="https://aiadvances.org/give-the-knowledge-layer-something-to-compute-foundry-iq-and-the-fabric-iq-ontology-measured-56aea5e1549f">Cekikj’s article</a> above. Every package, dependency and advisory in it is invented, and any resemblance to real software or real vulnerabilities is coincidental. The results come from small, quantised models running on one laptop, in a deliberately small world; they illustrate a pattern and are not a benchmark of any product or model. Nothing here is security advice. The views expressed are my own and not those of my employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7e26f858c57" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-scientists-from-future/rules-as-code-not-prose-letting-an-ontology-compute-its-own-rules-in-a-browser-tab-b7e26f858c57">Rules as Code, Not Prose: Letting an Ontology Compute Its Own Rules in a Browser Tab</a> was originally published in <a href="https://medium.com/data-scientists-from-future">Agentic Guru</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Neo4j Protege Plugin: Automate Knowledge Graph Creation with AI]]></title>
            <link>https://medium.com/data-scientists-from-future/neo4j-protege-plugin-automate-knowledge-graph-creation-with-ai-d9803a832b25?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/d9803a832b25</guid>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Sun, 30 Nov 2025 16:08:50 GMT</pubDate>
            <atom:updated>2025-11-30T16:08:48.951Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ts61RDYo9dXIXEskg_nWMA.jpeg" /></figure><p>Neo4j is the leading graph database platform for building powerful knowledge graphs. Knowledge graphs organize data as interconnected nodes and relationships, enabling businesses to discover insights hidden in complex datasets. With Neo4j’s native graph storage and Cypher query language, developers can create semantic knowledge graphs that power AI applications, recommendation systems, and real-time analytics. From fraud detection to drug discovery, Neo4j knowledge graphs transform how organizations understand and leverage their connected data.</p><p>Protégé is a free, open-source ontology editor and knowledge management tool developed by Stanford University. It’s widely used by researchers, developers, and organizations to create, edit, and manage ontologies — formal representations of knowledge that define concepts, relationships, and rules within specific domains.</p><p>You can get the plugin from <a href="https://github.com/vishalmysore/neo4j-protege-plugin">here</a></p><blockquote>🧠 Ready to test what you’ve learned in this article? Try a quiz on <a href="https://easyqz.online/">EasyQZ </a>after reading the article! 📚🎯</blockquote><p><strong>Key Features of Protégé:</strong></p><ul><li><strong>Ontology Development</strong>: Build complex semantic models using Web Ontology Language (OWL) and Resource Description Framework (RDF)</li><li><strong>Visual Interface</strong>: User-friendly graphical interface for designing class hierarchies, properties, and relationships</li><li><strong>Reasoning Support</strong>: Built-in reasoners that validate ontologies and infer new knowledge automatically</li><li><strong>Extensible Architecture</strong>: Plugin system that allows customization and integration with other tools</li></ul><p><strong>Common Use Cases:</strong></p><ul><li>Biomedical research (e.g., disease ontologies, drug databases)</li><li>Semantic web applications</li><li>AI and machine learning knowledge bases</li><li>Enterprise data modeling and standards development</li></ul><p><strong>Why Protégé Matters for Knowledge Graphs:</strong></p><p>Protégé excels at designing the semantic structure and rules that govern knowledge domains. When integrated with graph databases like Neo4j, Protégé-designed ontologies can be transformed into operational knowledge graphs, combining Protégé’s semantic rigor with Neo4j’s high-performance graph storage and querying capabilities.</p><p>Think of Protégé as the “architect’s blueprint” tool, while Neo4j is the “construction and operation” platform for knowledge graphs.</p><p>I created a plugin that connects Protégé (the popular ontology editor) with Neo4j (the graph database). The idea was simple: these are two great tools that should work together, but they don’t talk to each other out of the box. So I built a bridge between them.</p><h3>Why I Made This</h3><p>If you’ve worked with ontologies and knowledge graphs, you know the pain. You design your ontology carefully in Protégé, then you need to get that data into Neo4j. Or you have graph data in Neo4j that you want to use in your ontology. Usually, this means writing custom scripts, exporting files, transforming data — it’s tedious work.</p><p>I wanted to skip all that. Just connect the two tools directly and move data back and forth.</p><h3>What It Does</h3><p><strong>Natural Language Queries</strong></p><p>This was the fun part. Instead of writing Cypher queries (Neo4j’s query language), you can just ask questions in plain English like “get me all the nodes” or “find all reactions and symptoms.” The plugin uses AI (GPT-4, Claude, or free local models) to translate your question into the right Cypher query. It shows you what it’s going to run before executing, so you stay in control.</p><p><strong>Two-Way Data Flow</strong></p><ul><li><strong>Export to Neo4j</strong>: Take your Protégé ontology (classes, individuals, relationships) and push it into Neo4j as a graph</li><li><strong>Import from Neo4j</strong>: Pull data from your Neo4j database back into Protégé as ontology entities</li></ul><p>The imported data becomes part of your ontology immediately — you can use it with reasoners, write rules, whatever you normally do in Protégé.</p><p><strong>Works With Any Domain</strong></p><p>I didn’t build this for one specific field. Whether you’re working with medical data, research papers, manufacturing processes, legal documents, or anything else, it should work. The plugin doesn’t care what your ontology is about.</p><h3>Who Might Find This Useful</h3><ul><li>Researchers managing complex datasets</li><li>Knowledge engineers building semantic applications</li><li>Data scientists working with graph databases</li><li>Anyone juggling Protégé ontologies and Neo4j databases</li></ul><h3>How It Works</h3><p>You configure your Neo4j connection (cloud or local), optionally add an AI API key for natural language queries, and you’re ready to go. The interface lives right inside Protégé as a new tab.</p><p>When you ask a question in natural language, the plugin grabs your Neo4j schema first — all the node types and relationships you actually have. It sends that to the AI along with your question, so the generated query references real things in your database, not made-up labels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60hrTKz0asep04dBjCebjw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MupCY2EV1Ooa64u2l5UPOw.jpeg" /></figure><h3>Knowledge Graphs Are Becoming Essential</h3><p>Knowledge graphs are quietly becoming one of the most important technologies for the future, and here’s why.</p><h3>The Data Connection Problem</h3><p>We’re drowning in data, but most of it sits in isolation. Customer data in one system, product data in another, transaction records somewhere else. Traditional databases store information in neat tables, but they’re not great at showing how things actually relate to each other.</p><p>Knowledge graphs solve this by storing information the way we naturally think about it — as connected concepts. A customer bought a product, which was manufactured at a facility, which sources materials from suppliers. These connections matter, and knowledge graphs make them first-class citizens.</p><h3>AI Needs Context</h3><p>Here’s where it gets interesting for the future. Large language models like GPT and Claude are impressive, but they have a big limitation — they don’t know about your specific data, and they can hallucinate facts.</p><p>Knowledge graphs provide the grounding AI needs. Instead of asking an LLM to remember everything, you store facts in a knowledge graph and let the AI query it. This pattern (called Retrieval Augmented Generation or RAG) is becoming the standard way to build reliable AI applications.</p><p>Your knowledge graph becomes the “source of truth” while the LLM provides the natural language interface and reasoning.</p><h3>Real-Time Decision Making</h3><p>Knowledge graphs enable queries that would be nightmarishly complex in traditional databases. Want to find fraud patterns across millions of transactions? Recommend products based on what similar customers bought who also liked similar brands? Trace supply chain disruptions through multiple layers of suppliers?</p><p>These queries involve traversing many relationships — exactly what knowledge graphs are built for. They can answer in milliseconds what might take minutes or be impossible in relational databases.</p><h3>They Get Smarter Over Time</h3><p>Knowledge graphs aren’t static. As you add more data and relationships, they become more valuable. You can run reasoning algorithms to infer new connections you didn’t explicitly create. If John works at Company X, and Company X is a subsidiary of Corporation Y, the graph can infer John’s connection to Corporation Y.</p><p>This emergent intelligence makes them increasingly powerful as they grow.</p><h3>The Semantic Web Vision, Finally Practical</h3><p>For years, people talked about the “semantic web” — making data machine-readable and interconnected. It felt academic and distant. Knowledge graphs are making this real and practical.</p><p>When your data has semantic meaning (not just “column A relates to column B” but “Person X is_employed_by Company Y”), machines can reason about it. This enables automation, AI assistants, and intelligent systems that actually understand your business domain.</p><p>As AI becomes more embedded in everything we do, the systems that can provide reliable, connected, queryable knowledge will be the ones that win. That’s knowledge graphs.</p><p>They’re not replacing databases — they’re complementing them for the use cases where relationships and connections matter most. And increasingly, that’s almost everything.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9803a832b25" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-scientists-from-future/neo4j-protege-plugin-automate-knowledge-graph-creation-with-ai-d9803a832b25">Neo4j Protege Plugin: Automate Knowledge Graph Creation with AI</a> was originally published in <a href="https://medium.com/data-scientists-from-future">Agentic Guru</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Powered Robot Built with Anthropic Claude AI & MCP — The Future of Robotics!]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/ai-powered-robot-built-with-anthropic-claude-ai-mcp-the-future-of-robotics-801946e56b35?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/1059/1*BeVhKdqoVMz2WG8RSdgSvw.png" width="1059"></a></p><p class="medium-feed-snippet">Artificial Intelligence is no longer confined to software applications&#x200A;&#x2014;&#x200A;it&#x2019;s now revolutionizing robotics! Introducing Chotu Robo, an&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/ai-powered-robot-built-with-anthropic-claude-ai-mcp-the-future-of-robotics-801946e56b35?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/ai-powered-robot-built-with-anthropic-claude-ai-mcp-the-future-of-robotics-801946e56b35?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/801946e56b35</guid>
            <category><![CDATA[anthropic-ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[arduino]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Mon, 17 Mar 2025 21:50:22 GMT</pubDate>
            <atom:updated>2025-03-17T21:50:22.392Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Introduction to Model Context Protocol- Pet Store MCP Server]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/introduction-to-model-context-protocol-pet-store-mcp-server-1f8dd327f8de?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/1914/1*Y-pQV7T6mma9kldikXglew.png" width="1914"></a></p><p class="medium-feed-snippet">With Model Context Protocol (MCP), we can create a sophisticated AI assistant for a pet store, providing a richer experience for users&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/introduction-to-model-context-protocol-pet-store-mcp-server-1f8dd327f8de?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/introduction-to-model-context-protocol-pet-store-mcp-server-1f8dd327f8de?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/1f8dd327f8de</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 13 Mar 2025 21:34:36 GMT</pubDate>
            <atom:updated>2025-03-13T21:34:24.597Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Function Calling OpenAI with Java and Tools4AI]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/function-calling-openai-with-java-and-tools4ai-d01634132836?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/800/0*F8If1F4ZEb2yazNg.jpg" width="800"></a></p><p class="medium-feed-snippet">Introduction to Tools4AI</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/function-calling-openai-with-java-and-tools4ai-d01634132836?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/function-calling-openai-with-java-and-tools4ai-d01634132836?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/d01634132836</guid>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 16:58:29 GMT</pubDate>
            <atom:updated>2024-04-06T23:25:42.036Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[GenAI Hallucination: A Practical Example]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/genai-hallucination-a-practical-example-61ce6c408c43?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/1198/0*73XWLxbZrOUn_UP4" width="1198"></a></p><p class="medium-feed-snippet">Hallucinations seem to have become one of the most used word in terms of AI&#xA0;, so lets take a closer look at what Hallucinations are. I&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/genai-hallucination-a-practical-example-61ce6c408c43?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/genai-hallucination-a-practical-example-61ce6c408c43?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/61ce6c408c43</guid>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[hallucinations]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 13:54:42 GMT</pubDate>
            <atom:updated>2024-01-30T13:48:38.844Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to Shrink Your Model: A Guide to Model Quantization]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/how-to-shrink-your-model-a-guide-to-model-quantization-143d6d967e01?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/936/0*vDkARlHrK1y2mrbk" width="936"></a></p><p class="medium-feed-snippet">Quantization</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/how-to-shrink-your-model-a-guide-to-model-quantization-143d6d967e01?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/how-to-shrink-your-model-a-guide-to-model-quantization-143d6d967e01?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/143d6d967e01</guid>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[learn-ai]]></category>
            <category><![CDATA[quantization]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 13:53:44 GMT</pubDate>
            <atom:updated>2024-01-16T23:17:19.073Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Deploy Spring Boot APP on Hugging Face — For Free]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/deploy-spring-boot-app-on-hugging-face-for-free-92439db78701?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/830/1*038U6qM0N0e4rd0wBLqQCw.png" width="830"></a></p><p class="medium-feed-snippet">Overview</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/deploy-spring-boot-app-on-hugging-face-for-free-92439db78701?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/deploy-spring-boot-app-on-hugging-face-for-free-92439db78701?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/92439db78701</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[app-development]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[hugging-face]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 13:52:46 GMT</pubDate>
            <atom:updated>2024-04-13T16:15:51.685Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Tools Integration with Gemini and Java]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/large-action-model-with-gemini-and-java-2eeac37cad12?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/720/0*fxFTsqbtseAdnkOM" width="720"></a></p><p class="medium-feed-snippet">Tools vs Large Action Model</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/large-action-model-with-gemini-and-java-2eeac37cad12?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/large-action-model-with-gemini-and-java-2eeac37cad12?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/2eeac37cad12</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[java8]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 13:52:14 GMT</pubDate>
            <atom:updated>2025-03-30T15:37:54.083Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Why Build a ChatBot When You Can Create a LLM Agent on OpenAI or Gemini]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/data-scientists-from-future/why-build-a-chatbot-when-you-can-create-a-llm-agent-on-openai-or-gemini-689b841bc0f5?source=rss----2fbb407b05fd---4"><img src="https://cdn-images-1.medium.com/max/600/1*BcvTAAooZ-PzTd_oJ8LD8w.png" width="600"></a></p><p class="medium-feed-snippet">In Past few months ChatBots have gained significant popularity as a means of automating customer interactions and providing instant&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/data-scientists-from-future/why-build-a-chatbot-when-you-can-create-a-llm-agent-on-openai-or-gemini-689b841bc0f5?source=rss----2fbb407b05fd---4">Continue reading on Agentic Guru »</a></p></div>]]></description>
            <link>https://medium.com/data-scientists-from-future/why-build-a-chatbot-when-you-can-create-a-llm-agent-on-openai-or-gemini-689b841bc0f5?source=rss----2fbb407b05fd---4</link>
            <guid isPermaLink="false">https://medium.com/p/689b841bc0f5</guid>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[gemini]]></category>
            <dc:creator><![CDATA[Vishal Mysore]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 13:48:46 GMT</pubDate>
            <atom:updated>2024-05-01T22:51:30.214Z</atom:updated>
        </item>
    </channel>
</rss>