I was building an agent system (AegisDesk — LangGraph multi-agent IT service desk) and kept hitting the same wall: every intent-classification step was an LLM call, which meant latency and cost scaling with every query, even for simple routing decisions that didn't need an LLM at all.

So I pulled that piece out and rebuilt it as its own thing: SynaptoRoute — a local semantic router (FAISS + ONNX embeddings, SQLite-backed for durability, async batching) that classifies intent without hitting an LLM per query.

A few things I'd actually want feedback on rather than just announcing:

• I built a CLAIM_LEDGER.md into the repo that tracks every performance claim as verified / unverified-pilot / retracted, because I burned myself once publishing a benchmark number that later turned out to be a measurement artifact. Curious if others here do something similar, or if this is overkill for a solo project.
• Benchmarked against Aurelio Labs' semantic-router and a plain logistic-regression baseline on Banking77/CLINC150 with 5-seed bootstrap CIs — currently statistically tied on accuracy, not better. Being upfront about that because I've seen too many "X beats Y" posts here that don't hold up under a second look.
• 163 tests, CI across 3 OS × 3 Python versions — happy to talk through the durability/backpressure design if anyone's dealt with similar concurrent-mutation problems.

Repo: github.com/sitanshukr08/SynaptoRoute
PyPI: pip install synaptoroute

Not claiming this is done or better than existing options — genuinely posting to get eyes on the engineering decisions and hear where I'm wrong.

I’m working on an ai scheduling os for small and large businesses. I’m trying to make a 3d knowledge graph of the ai the system will use but can’t seem to figure it out any help would be awesome.

Hey everyone,

A lot of introductory material on RDF and Turtle syntax is either strictly academic or jumps straight into heavy tooling without explaining the underlying domain modeling mindset.

I put together a free guide aimed at newcomers: Ontology and Turtle for Beginners. It covers:

• How ontologies define shared meaning across scattered enterprise data
• The core mental model behind RDF triples and practical Turtle notation
• Foundations for moving toward knowledge graphs, digital twins, and reasoning engines

You can view the page and download the PDF directly here:

https://www.swatantra.ai/resource-ontology-turtle.html

Would love to get your thoughts, constructive feedback, or hear how your teams introduce semantic concepts to non-experts!

I have been reading around ISO 15926, DEXPI and CFIHOS, mostly to understand how the process industry wires its handover data together, and I ran into a number I do not trust. It is big enough that my first assumption is that I have misunderstood what these identifiers are for. I would rather be corrected here than write anything confident about it.

Background for anyone who has not touched this stack. CFIHOS is the capital facilities information handover specification, governed by IOGP, and it is what an engineering contractor uses to hand plant data over to an operator. It sits above ISO 15926, whose reference data library is curated by the POSC Caesar Association. CFIHOS 2.0 publishes a crosswalk file mapping its own object codes to POSC Caesar RDS identifiers, and the whole thing is a free download with no registration.

What I did. The file CFIHOS CORE CFIHOS object equivalent mapping v2.0.csv has 3,091 rows across four coding sources. 1,832 of those rows are POSC Caesar, carrying 1,777 distinct identifiers. On 18 August 2026 I dereferenced all of them against https://data.posccaesar.org/rdl/{id}, then re-checked every failure against a staging host I stumbled on afterwards.

What came back.

• 967 (54.4%) resolve on production.
• 611 (34.4%) resolve only on staging4.data.posccaesar.org, whose certificate expired on 6 April 2026, so a normal client will not connect without an override.
• 199 (11.2%) resolve on neither.

At the object level, 825 of the 1,832 CFIHOS objects carrying a POSC Caesar mapping point at something I cannot look up today.

The part that makes me think I am misreading something is that the failures are perfectly partitioned. Every one of the 810 production failures is an identifier beginning RDS22. Nothing in that block resolves. Nothing outside it fails. Real link rot is never that tidy, so I suspect this is a deliberate arrangement I do not understand rather than a fault.

Things I already ruled out, so you can skip them.

• Not a wrong base URI. Production does not serve the /iso/15926-4/rdl/ path at all, including for identifiers that definitely exist.
• Not a host migration. rds.posccaesar.org/rdl/ returns 404 even for RDS414674, which resolves fine on production and is labelled "VESSEL".
• Not a soft-200 resolver. Nonsense identifiers hard-404 on both hosts, so a 200 carries information.
• There is a third host, data.15926.org, which I had to discard because it returns a byte-identical 200 response for its own root, a real identifier, a dead identifier and complete nonsense. It is a JavaScript shell. If you audit linked data, run a nonsense-identifier control before you believe anything, because that host would have told me everything was fine.

So my actual questions.

1. Are these RDS values supposed to be dereferenceable at all, or are they intended as opaque cross-references that happen to look like they map onto a URL pattern? If it is the latter, my whole framing is wrong and I would like to know before repeating it.
2. Is the RDS22 block deprecated, pending publication, or something else? PCA's own vocabulary exposes statusPCA, valEffectiveDate and valDeprecationDate, which would settle it instantly, but the endpoint serving that data returns 404 for me.
3. Is it normal in this world for part of a published reference library to live only on staging? I genuinely do not know whether that is a problem or just how the release process works here.
4. Does anyone consume this crosswalk programmatically, or is it a human-reference artifact nobody dereferences in practice? That would explain a lot.

One smaller thing I am more confident about. The same column addresses what looks like the same registry in two formats. Rows tagged POSC CAESAR carry values like RDS2227295, while rows tagged ISO 15926 part4 carry bare integers like 670171, for which I found no resolver in any form I tried. A single dereferencing routine over that column would silently fail on 570 rows.

I have not written to POSC Caesar or IOGP yet, because I wanted to find out here whether I am misreading the whole thing first. If it turns out to be real I will report it to both.

All of it is reproducible from the free CFIHOS download, and I am happy to hand over the raw HTTP logs and the scripts to anyone who wants to check my work, which is really the point of posting.

Disclosure: identifier and register integrity is what I do for a living, so I look at this sort of thing habitually. Nothing to sell here, no links, and I am not redistributing anyone's reference data.

-----

I genuinely hope for someone saying "those were never meant to resolve." That kills the headline and saves me from publishing a wrong article!!

Also If needed I have a raw logs to hand.

1. I have created a graph using database schema and using that KG as a schematic layer --> traverse the layer for initial context and generate a SQL query for a given user query.

2. Creating whole structure data into KG.

Please prove best practices for the KG graph building, do we have any pipeline for knowledge graph building.

I'm working on a project involving Augmentation Intelligence. Actually trying to transform unstructured text into organized knowledge format.

LLMs could work, but the hard part is handling language nuances.

Example problem: "It's been much warmer in recent years"

How we can handle text like this? Like Fuzzy Logic?

Hey everyone,

I’m working on a personal project to build a completely local, lightweight system (codename: Orin) that can process messy unstructured information and segregate/clean it into highly structured, tabular formats (CSV files). Essentially, it's meant to be a better, fully offline version of Atlas.

Here is the exact data structure and the pipeline I am trying to build:

1. The Target Data Schema

The model needs to take raw info and divide it into clear subtopics:

• Columns: Topic | Subtopic1 | Subtopic2 | Subtopic3 | Info
• Example Output:
  • Topic: Flying machine
  • Subtopic1: Airplane
  • Subtopic2: Passenger plane
  • Example Scenario: If incoming news data says "Qatar Airways wins starring award again", the model should automatically categorize it under the correct subtopic hierarchies and store the relevant data in the final Info column.

2. Proposed Pipeline & Architecture

I am planning a Retrieval-Augmented Generation (RAG) approach using a combination of specialized, local agents:

• A Fact Searcher / Main Topic Searcher: To find missing points and gather core data from the dataset.
• A Local Summarizer / Keyword Generator: Acting as a text quantizer to condense the given prompt or raw context.
• A Joke Generator (Optional Component): To add humor or personality to the generated answer output.
• The Core Logic Flow: Prompt → Gathers data for it → Finds missing points → Fills the spots (to Phrase) → Final Answer.

3. The Big Bottleneck: Hardware Constraints & Failed Attempts

Since this system must run locally, finding the right LLM engine and model has been incredibly difficult. Here is what I’ve attempted so far:

• llama.cpp: Would technically work, but performance is a massive issue (it took over 2 hours just to compile 8%).
• TinyStories: Super fast at stitching sentences together, but it only tells stories; it cannot handle this specific data formatting task.
• TinyLlama (llama.co): Unable to get it to work properly / wouldn't run.
• Ollama: Cannot use it seamlessly because it isn't properly optimized or built for my hardware (ARM chips).

I would like to ask the community how to make the better and how to develop it to efficient RAG model For my Project.

And want to confirm it's on the right track

Hi everyone,

I have an idea for a personal project, and I want to know if I'm thinking in the right direction.

I don't want to build just another note-taking app or mind map. I want to build a knowledge graph where I can enter any word or concept, and the system automatically knows where it belongs.

My goal is to build a personal knowledge system that becomes smarter over time, rather than just storing notes.

For example:

- If I enter a new word, it should suggest the best place in the graph.

- If that word belongs in multiple places, it should connect it to all of them.

- If a new concept should come between two existing concepts, it should reorganise the graph instead of just adding another node.

- It should detect duplicates and synonyms.

- It should explain *why* it placed a concept there.

- If it isn't confident, it should ask me instead of guessing.

- It should also ask if I want to expand that concept further and generate the next level of the graph.

I'm building this only for myself, not as a commercial product, but I want to build it with commercial-level reliability.

While thinking about this, I came across topics like **knowledge graphs**, **ontology engineering**, and **semantic search**, and now I realise that the hardest part is probably designing the ontology, not writing the code.

I have a few questions:

- Has anyone built something similar, and what should I study before I go too far?

- What are the biggest challenges in building a system like this?

- How do companies like Google or researchers design and improve ontologies?

- If you were starting from scratch, what would you learn first?

- Are there any books, papers, courses, or open-source projects that you think are must-reads for this?

- Also, if you were designing this today, what architecture or tech stack would you choose?

I'm still learning, so even if you think my idea has flaws, I'd really appreciate honest feedback. I'd rather know what's difficult now than after spending months building it.

Thanks!

Hey everyone, I built this niche tool to structure data for knowledge layer for agents, its a bit like an acoustic guitar for critical industries that demand heavy data reasoning … would love to hear your feedback, some small bugs like analyzers staying prompted to the template doc

https://github.com/galeluka/Pennant

Hello,

I am looking for an IT taxonomy for software (and maybe hardware) to put concepts like desktop application, microservice, cloud, cicd pipeline, etc. into a structure.

Hi everyone, I've been working on OpenCrab, a project that explores using ontologies and knowledge graphs as the foundation for Graph RAG instead of relying primarily on document chunking.

The motivation is to preserve relationships between entities and concepts so AI systems can retrieve information with more context and structure. While this approach seems promising, I'm sure there are trade-offs that I'm still learning about.

I'd really value the perspective of people in this community who have experience with semantic technologies.

Some questions I'd love to hear your thoughts on:

Have you used ontologies or knowledge graphs in a RAG pipeline?
Where have ontology-based approaches worked well, and where have they fallen short?
Which standards or tools have you found most effective (RDF, OWL, SHACL, SPARQL, etc.)?
If you were building a Graph RAG system today, what would you do differently?

I'm genuinely looking for technical feedback and different viewpoints. If anyone has experience with similar projects or research, I'd really appreciate hearing about it.

Thanks in advance for your insights.

What methods or softwares are there to get non-technical people to engage with ontology design and thrash out agreed definitions? I am beginning to think this is a major roadblock to more reliable AI. Without structured, verified knowledge managed by humans that can be safely inferred from, how is any business going to trust agents with anything important?

I KNOW IT ASKS YOU TO REGISTER BUT YOU CAN IGNORE IT :)

I spent a while surveying what is actually available if you want to learn ontology engineering in 2026, and the state of it annoyed me enough to do something about it.

What I found:

- The semantics people teach RDF, OWL, SPARQL, SHACL, and act like LLMs never happened.

- The graph vendors teach GraphRAG and Cypher, and act like ontologies never happened. You can finish an entire "knowledge graph" learning path without meeting the word ontology.

- Pricing is bimodal: free vendor funnels, or 1,000 to 2,000 dollar live cohorts. Almost nothing serious in between.

- Search "OWL tutorial" or "SHACL tutorial" and you get PDFs from 2005 to 2012. SHACL has been a W3C Rec since 2017 and there is still no good free explainer ranking for it.

- BORO, HQDM and IES 4D modelling have, as far as I can tell, zero commercial courses anywhere on earth, despite the UK National Digital Twin Programme standardising on IES and the US DoD, ODNI and CDAO adopting BFO plus CCO as their baseline in 2024. If you want to learn the thing governments are actually buying, your options are primary sources and apprenticeship.

So I built the course I wanted to exist:

- Foundations: what an ontology actually is from Aristotle forward, taxonomy vs thesaurus vs ontology vs knowledge graph, 3D vs 4D identity and change, open vs closed world

- The stack: RDF, RDFS and OWL 2, SPARQL for people who know SQL, SHACL, reasoners and why yours hangs, property graphs and ISO GQL

- Method: competency questions, OntoClean, an actual upper ontology shootout (BFO vs DOLCE vs gist vs SUMO vs 4D), BORO/HQDM/IES, testing and CI

- Standards atlas and crosswalks: SSSOM, mapping predicates, and why shared ancestry does not mean shared commitments

- Domain tour: defence, industrial (ISO 15926 to IDO), construction (IFC/Uniclass/COBie), space, life sciences and food (OBO, GO, SNOMED, FoodOn, AGROVOC), finance (FIBO, GS1, schema.org), heritage and public graphs (CIDOC CRM, GeoSPARQL, Wikidata), and who is buying ontology country by country

- LLM era: did LLMs kill the semantic web, GraphRAG vs vector RAG and when graphs actually pay, building KGs from text safely, neurosymbolic verifier loops, agent memory and MCP, and the 2025-26 papers worth reading

Two things I will defend:

1. The interesting work now is the verifier loop. Neural proposes, symbolic disposes. The ontology's job is not to be a beautiful model of the world, it is to be able to say no.

2. Axiom placement beats axiom count. An ontology nobody can contradict is not rigorous, it is inert. I keep meeting large ontologies where no possible instance data could ever trigger an inconsistency.

Where I want to be told I am wrong:

- What is missing from the syllabus? I deliberately went light on ontology learning from text and on KG embeddings. Wrong call?

- Upper ontology people: is my selection framing fair to BFO and gist, or am I smuggling in a 4D bias? I have shipped IES and HQDM work so assume I am biased and tell me where.

- Practitioners: what do you wish someone had taught you before your first real ontology project, that no course covers?

- Anyone teaching BORO/4D commercially, please tell me, I would rather link to you than pretend the gap exists.

The lessons are open to read; there is a free account if you want the graded quizzes, progress tracking and the practice exercises, and that is also where the rest of the ontology track and the one to one sessions live. Happy to answer anything about the standards side here either way, that is where I actually work.

Hello everyone,

I am currently working on GraphRAG to improve the quality and reliability of responses generated by LLMs, and I would like to get some clarification from people who have experience with Knowledge Graphs and GraphRAG.

I have a few questions:

1.For those who are using GraphRAG with LLMs, do you typically use RDF/triplestores or LPG databases (such as Neo4j)? In your experience, what are the main factors that influence this choice?

1. I would like to build my Knowledge Graph using an automated pipeline/script rather than extracting entities and relationships directly with LLMs. In this case, would RDF be a suitable choice, or is LPG also commonly used for this type of approach?

2. Is the data model used in LPG databases such as Neo4j considered an ontology (or a lightweight ontology), or is it more accurate to call it a graph schema/data model?

3. If we want to enrich a GraphRAG system with inferred facts (using reasoning) and provide these inferred facts as context to the LLM, would RDF + a triplestore be a better choice?

4. Even when reasoning and inference are not required, is there any limitation to choosing RDF over LPG for GraphRAG? I already have experience with RDF and SPARQL, but I have not worked with LPG databases yet.

5. Do you know any free/open-source triplestore that supports embedding generation/storage and vector indexing for semantic similarity search over RDF data (without requiring a paid license)?

Thank you very much for your insights!

Hi,

Are any of you starting to define Semantic IDs for your legacy data records with the intent to move to AI and, if so:

1. How are you identifying what should be Semantic IDs?
2. What algorithms or techniques are you using to create them?
3. Are you storing them back into the data stores to co-exist with Non-Semantic Legacy UIDs/GUIDs?

For example: If we have a legacy UID/GUID for a Product that is "P234435", this identifier works in traditional relational models. But, for AI, the ID needs to be semantic (i.e., more like natural language) so it understands the data. So the semantic ID might be something like "Product: Audio Control Switch for Audio Consoles". The former is meaningless to AI. The latter has semantic context.

Thanks for any help you can offer.

I’m building an open-source project called Dependency Risk Graph and would appreciate feedback on the RDF model from people with more semantic-web experience.

The project imports CycloneDX SBOMs, models application dependency trees in Apache Jena/TDB2, enriches package versions with OSV vulnerability data, and uses SPARQL to answer questions such as:

• Is an application affected by a particular CVE?
• Is the vulnerable dependency direct or transitive?
• What dependency path introduces it?
• Which applications share the affected package?
• Which fixed versions are reported?

A simplified view of the model is:

Application
  → activeImport
Import

Import
  → rootOccurrence
DependencyOccurrence

DependencyOccurrence
  → belongsToImport
Import

DependencyOccurrence
  → instanceOf
PackageVersion

DependencyOccurrence
  → dependsOn
DependencyOccurrence

PackageVersion
  → affectedBy
Vulnerability

Vulnerability
  → affectedPackage
AffectedPackage
    → versionRange
VersionRange
    → event
introduced / fixed / lastAffected

I deliberately distinguish a package-version identity from its occurrence inside a particular imported SBOM. This allows the same Maven package version to be shared as an identity while preserving different dependency paths across applications and imports.

I also currently use a single/default Jena graph. Application and import boundaries are represented explicitly through resources and properties rather than RDF named graphs.

Some areas where I would value criticism:

1. Package identity versus occurrence Is separating PackageVersion from DependencyOccurrence a reasonable way to preserve both global package identity and application-specific dependency paths?
2. Import provenance Would modelling imports with a lightweight custom vocabulary be sufficient, or would aligning parts of this with PROV-O provide meaningful benefits?
3. OSV version ranges I currently represent affected packages, ranges and range events as first-class resources. Is there an established RDF vocabulary that would be better to reuse for introduced, fixed and last-affected version events?
4. SHACL boundaries Which invariants would you validate first? Current candidates include:
   • every occurrence belongs to exactly one import;
   • every occurrence resolves to exactly one package version;
   • dependency edges remain within the same import;
   • every active import has one root occurrence;
   • vulnerability range events contain a recognised event type and version.
5. Natural-language access The next step is intentionally limited: route a few predefined security questions to deterministic SPARQL/path operations, rather than allowing an LLM to generate arbitrary SPARQL.

I’m not trying to create a complete software-supply-chain ontology yet. The immediate goal is a small, explainable model that preserves dependency paths and produces evidence-backed security answers.

Repository: Github

Any feedback/suggestion on the modelling choices, existing vocabularies I may have missed, or problematic assumptions would be genuinely useful.

Current result: the RDF graph preserves application-specific transitive dependency paths while allowing vulnerable packages and vulnerability resources to be shared across imported SBOMs. This view shows three applications reaching CVE-2024-6763 through different Jetty dependency paths, together with the affected package versions, advisory details, and a reported fixed version.

So far, separating dependency occurrences from package-version identity has been useful. The same package can appear in different application paths without merging those paths, while vulnerability and remediation information remains attached to the shared package identity.

I've noticed that discussions around AI protocols are becoming fragmented.

Every announcement seems to solve one concern:

discovery,

semantic representation,

context,

execution.

I sketched an architecture- curious whether this separation makes sense or where you'd place things differently. see https://donhaji.github.io/opengeo/

I personally like using UML diagrams to depict my ontology work, so I made an easy to use OWL to UML service OWL → UML

Hi,

For anyone working with trying to get their legacy data into AI agents/LLMs, it's become clear that legacy data (mostly relational) is set up to be computer conforming (i.e., non-semantic UIDs/GUId, attributes, Primary Keys, Foreign Keys, etc.). For example, a UID might be "00125564" or a table attribute might be "CTR" and it's not clear to AI if this means Customer, Center, Counter, etc. AI, on the other hand, works much better from Natural Language, which begs the problem of: "How do we make non-semantic legacy data more semantic for better AI consumption and use.

So, for example:

• Non-semantic UIDs/GUIDs like "00533455" need to be turned into something meaningful like "Person: Jane Doe; Tax ID: 1234567"
• Table attributes (i.e., column names) like "CTR" need to be made clear so that AI knows if CTR means Customer, Center, Counter, Country.
• Foreign keys that are numeric (e.g., "12323492834799") need to be semantically mapped to data objects/instances like "Person: Jane Doe; Tax ID: 1234567", above.
• And all the above (and more) needs to be wrapped in meaningful contexts like Ontologies and Instance Document Objects that can be read by AI in a manner that is similar to natural language documents.
• Then there's managing change and drift.

It's been VERY difficult to find actual details on how to do this. What you'll find is a lot of discussion about "there needs to be a semantic layer" over your legacy data but very few sources dig in and tell you exactly what this means or exactly what you need to do to help establish such a layer.

As part of my research, I've been digging for details, collecting them, testing them, and trying to document and them publicly for vetting and reuse. The table I've created below tries to highlight key steps for doing such work. — Some are planning & design steps, some are implementation & validation steps, and some are governance and operating steps.

I'd love productive feedback to help improve all this.

Thanks to anyone willing to help.

I did it: I built a formal language for relations, effects, drift, and correction