[prasmuss15]

Hey, thanks for the feedback! I'm one of the devs on graphiti and adding support for custom schema is high on our to-do list. I agree that this is an important step in helping to bridge the gap between structured and unstructured data, as well as for refining the graph on specific use cases.

Currently, we do have some ways of helping the graph to understand what nodes and edges "really mean." In addition to the name of the relationship our edges also store a "hydrated" version of the fact triple. For example, if Alice and Bob are siblings you might see an edge with the name IS_SIBLING_OF between the two. In addition to this, the edge also stores the fact: "Alice is the sibling of Bob". This way we are storing much of the semantic context on the nodes and edges themselves in addition to the graph structure.

We also support ingesting structured JSON, and I those cases the edges will be exactly the properties in the JSON doc.

[spothedog1]

The reason I bring RDF is because I use ontologies that have been defined by experts and covers ton of edge cases. If a group of genealogists define a `fam:` RDF Ontology and publish it, then I want every family relationship in my graph to use their Ontology.

I'm looking for something like graphiti that can take in a text block and when creating the relationships, automatically know to use the `fam:` ontology when creating familial relationships. The vast majority of people don't feel like defining schemas for every little thing and they're basically the same across all systems except for custom proprietary ones you define as your IP.

Their ontology would have OWL rules like `fam:isChildOf` `owl:inverseOf` `fam:isParentOf` so running an OWL Reasoner over the graph would generate the inverse triples as well

So if I had the text `Joe is Bob's dad`, input it into graphiti, then get the triples

person:Joe fam:isParentOf person:Bob person:Bob fam:isChildOf person:Joe

and the edge would be in a shared definition amongst all graphiti users. The LLM can be fine tuned to recognize exactly what fam:isParentOf means so there is no ambiguity. Right now I'm guessing graphiti could spit out edges `IS_SIBLING_OF` `SIBLING` `SISTER` `BROTHER` etc, its not standardized which makes it difficult to interact with computationally if say, I wanted to input a bunch of random text and then run pre-trained graph models of family networks.

[prasmuss15]

Thanks for the follow-up and the in depth example and explanation. Like you said, supporting ontologies is definitely a core use-case of KG's and there are also many standard preexisting taxonomies for different things (Google and Amazon both famously have taxonomies that try to cover everything, and there are many other specialized ones as well).

I don't think I was clear enough when I mentioned our plans to add custom schema. The way we are thinking of implementing this idea is by allowing end users to provide specific node types and edge types between those nodes. Then we can pass that information on to the LLM and instruct it to extract only nodes and edges that conform to the provided schema. We would also have methods to verify the output before adding it to the graph.

So in this scenario you could input something like: { NodeType: Person, EdgeTypes: [IS_PARENT_OF, IS_CHILD_OF] }

Always extracting creating inverse relationships as well isn't something we've discussed yet but I think it's a great idea. Happy to hear any other thoughts you have or if you think there is a flaw in our approach to the custom schema to begin to solve the issue you've raised.

Edit: I think part of what you are saying just clicked for me. I think you're suggesting that the graphiti team chooses some open source taxonomy (like Google or Amazon) that we determine as our core taxonomy, and then fine tune an LLM on that data and open-source it? Then users can choose to use that fine-tuned LLM and get consistent schema relationships across the board? I think that is a really cool idea, but probably not something we would be able to do in the foreseeable future. We want the graphiti open source project to not be that opinionated, and we want to allow users to choose or fine tune their own LLMs for their specific use cases.

[mehh]

Yeah, but you’re kinda missing the point, there is an existing eco system of ontologies and technologies using RDF, without need to reinvent something likely not as well thought out.

[prasmuss15]

I'm not quite sure I follow. Today, graphiti extracts entities as nodes and facts between those nodes as edges. The nodes and edges store semantic data, like summaries of entities and facts representing the relationships between them (in addition to other metadata). Our searches are also based on this semantic data, and we aren't intending the extracted edge names to be used as filters as we are not doing any taxonomical classifications of nodes and edges.

In the near future, we intend to allow users of graphiti to input a custom schema (ontology), and we would use that to enforce a classifications of the extracted nodes and edges. In this case we are un-opinionated on what custom schema is being provided. You would be able to use an ontology that is made in-house or one of the many open source ones that exist in whatever field you are working in.

In neither case are we trying to recreate our own custom ontology or reinventing the wheel on how things are being classified.

[spothedog1]

Say I have a news article that describes a Government agency with a few departments and people who work in that department. Graphiti gives 2 options

1. Use whatever node and fact schemas Graphiti comes up with will be different everytime because it's using a non-deterministic LLM

2. Input my own schemas

1 will not be standardized deterministically, 2 will require a lot of work from me to figure out how to structure an organization. There are a million edge cases to think through

I think a big value add would be to just automatically use the Organization Ontology [1] and everyone who uses Graphiti on a text block that describes an organization will get that back.

Then defacto everyone's schemas can interact with each other. My business value prop is not going to be in defining an organization's structure, but it's still useful data for me have. Forming good Ontologies takes a lot of work.

I was thinking of just fine tuning my own LLM with RDF ontologies so it always returns graphs formatted in commonly used RDF schemas

[1] https://www.w3.org/TR/vocab-org/

EDIT: Just saw your edit 2 comments above. And yes exactly that is what I think would be useful. I'm looking for a project in this space that is opinionated cause frankly using a graph with a random assortment of node and edge types everytime I run it is not very useful.

[codewithcheese]

> So in this scenario you could input something like: { NodeType: Person, EdgeTypes: [IS_PARENT_OF, IS_CHILD_OF] }

RDF, OWL are existing formats for defining a schema

[chatmasta]

Have you seen TerminusDB? [0] They’ve got a nice solution to versioned RDF graphs, originally pitched as “Git for data” but focused on knowledge graphs.

I’m not affiliated (in fact they launched around the same time that my co-founder and I launched Splitgraph with the same “Git for data” pitch), but I find their technology very intriguing.

Knowledge graphs are on the cusp of revival after being in stasis for 20 years. They’re a perfect match for LLMs and I’m excited to see how the field adopts them.

[0] https://terminusdb.com/