Woow agents

.gitignore

@@ -0,0 +1 @@
+.env

agents.py

@@ -0,0 +1,97 @@
+import os
+from smolagents import CodeAgent, OpenAIServerModel
+from tools import (
+    validate_rdf_syntax,
+    get_entities_from_kg,
+    get_types_from_ontology,
+    get_relations_from_ontology,
+)
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+# model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
+
+# model = TransformersModel(model_id=model_id)
+
+model = OpenAIServerModel(
+    model_id="qwen/qwen-2.5-coder-32b-instruct:free",
+    # model_id="microsoft/mai-ds-r1:free",
+    api_base="https://openrouter.ai/api/v1",
+    api_key=os.environ["OPENROUTER_API_KEY"],
+)
+
+# web_agent = CodeAgent(
+#     tools=[DuckDuckGoSearchTool()],
+#     model=model,
+#     name="web_search_agent",
+#     description="Has the tools to run web searches for you. Give it your query as an argument."
+#     # prompt_templates=PromptTemplates(system_prompt="")
+# )
+
+# TODO: Add RDF specification tool, CACAO ontology tool, reasoning tool?
+ner_agent = CodeAgent(
+    tools=[],
+    model=model,
+    name="named_entity_recognition_expert",
+    description="An agent that is an expert in Named Entity Recognition. Named Entity Recognition (NER) is a subfield of computer science and Natural Language Processing (NLP) that focuses on identifying and classifying entities in unstructured text into predefined categories, such as persons, geographical locations and organizations. Provide content to this agent to detect the entities inside.",
+)
+
+et_agent = CodeAgent(
+    tools=[get_types_from_ontology],
+    additional_authorized_imports=["rdflib"],
+    model=model,
+    name="entity_typing_expert",
+    description="An agent that is an expert in Entity Typing. tasks provide fine-grained and ultra-grained type information for entities such as scientists, clubs, and hotels and is the process of categorizing named entities into predefined types. Provide named entities to this agent and expect typed entities back.",
+)
+
+el_agent = CodeAgent(
+    tools=[get_entities_from_kg],
+    model=model,
+    additional_authorized_imports=["rdflib"],
+    name="entity_linking_expert",
+    description="An agent that is an expert in Entity Linking. Entity Linking (EL) tasks, or entity disambiguation, involves identifying named entities within a text and linking them to their corresponding entries in a knowledge graph. Provide typed entities to this agent to link them to an existing knowledge base.",
+)
+
+co_agent = CodeAgent(
+    tools=[],
+    additional_authorized_imports=["rdflib"],
+    model=model,
+    name="coreference_resolution_expert",
+    description="An agent that is an expert in Coreference Resolution. Coreference Resolution (CO) focuses on determining when two or more expressions refer to the same entity. Provide texts to this agent to find out which texts refer to the same entities.",
+)
+
+re_agent = CodeAgent(
+    tools=[get_relations_from_ontology],
+    model=model,
+    additional_authorized_imports=["rdflib"],
+    name="relation_extraction_expert",
+    description="An agent that is an expert in Relation Extraction. Relation Extraction (RE) involves identifying facts about relations between extracted entities. Provide a text and entities to this agent to find relations between the entities from the text.",
+)
+
+# ch_agent = CodeAgent(
+#     tools=[DuckDuckGoSearchTool()],
+#     additional_authorized_imports=["rdflib"],
+#     model=model,
+#     name="cultural_heritage_domain_expert",
+#     description="Has extensive knowledge of cultural heritage. Ask it about the correctness of facts and the interpretation of a knowledge graph. It also has access to the internet to check facts.",
+# )
+
+kg_agent = CodeAgent(
+    tools=[validate_rdf_syntax],
+    additional_authorized_imports=["rdflib"],
+    model=model,
+    name="knowledge_graph_expert",
+    description="Has extensive knowledge on knowledge graphs. Has the final say before writing the output to a file.",
+)
+
+manager_agent = CodeAgent(
+    # Using N = 2, following the example of the HF team: https://huggingface.co/blog/beating-gaia
+    tools=[],
+    additional_authorized_imports=["rdflib"],
+    model=model,
+    managed_agents=[ner_agent, et_agent, el_agent, co_agent, re_agent],
+    planning_interval=2,
+)

app.py

@@ -1,4 +1,6 @@
 import gradio as gr
+from agents import manager_agent
+
 
 # Define a simple function that the Gradio app will use.
 # This function takes a string as input and returns its reverse.
@@ -22,11 +24,11 @@ def reverse_text(text):
 #   - title: A title for the Gradio app.
 #   - description: A brief description of the app.
 iface = gr.Interface(
-    fn=reverse_text,
+    fn=manager_agent.run,
     inputs=gr.Textbox(lines=2, placeholder="Enter text here...", label="Input Text"),
-    outputs=gr.Textbox(label="Reversed Text"),
-    title="Text Reverser",
-    description="Type some text into the input box, and the app will reverse it for you!"
+    outputs=gr.Textbox(label="Final output"),
+    title="KGC Agents",
+    description="Type some text into the input box, and the app will create a knowledge graph for you!"
 )
 
 # Launch the Gradio app.

requirements.txt

@@ -0,0 +1,2 @@
+smolagents[all]
+rdflib

tools.py

@@ -0,0 +1,171 @@
+from rdflib import Graph, RDF, RDFS, OWL, term, URIRef
+
+from rdflib.exceptions import ParserError
+from smolagents import tool
+
+
+@tool
+def validate_rdf_syntax(
+    file_path: str, file_format: str = "turtle"
+) -> tuple[bool, str]:
+    """
+    Validates the syntax of an RDF file.
+
+    This function parses an RDF file using the specified format and checks if it
+    is syntactically valid.  It handles potential parsing errors and other
+    exceptions that may occur during the validation process.
+
+    Args:
+        file_path (str): The path to the RDF file to validate.
+        file_format (str, optional): The RDF file format.
+            Defaults to "turtle".  Other common formats include "xml" (for RDF/XML),
+            "nt" (for N-Triples), and "nq" (for N-Quads).
+
+    Returns:
+        tuple: A tuple containing two elements:
+            - bool: True if the RDF syntax is valid, False otherwise.
+            - str: A message describing the validation result.  If the syntax is
+              valid, the message is "RDF syntax is valid.".  If there is an error,
+              the message provides details about the error.
+
+    Raises:
+        ParserError: If the RDF file has invalid syntax according to the specified format.
+        Exception: For any other unexpected error during file processing or parsing.
+    """
+    g = Graph()
+    try:
+        g.parse(file_path, format=file_format)
+        return True, "RDF syntax is valid."
+    except ParserError as e:
+        return False, f"RDF syntax error: {e}"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {e}"
+
+
+@tool
+def write_rdf_to_file(filename: str, text: str) -> None:
+    """
+    Writes the given text to a file.
+
+    Args:
+        filename (str): The name of the file to write to, without extension.
+        text (str): The text to write to the file.
+    """
+    try:
+        with open(f"{filename}.ttl", "w") as file:
+            file.write(text)
+        print(f"Successfully wrote text to {filename}")
+    except Exception as e:
+        print(f"An error occurred while writing to {filename}: {e}")
+
+
+@tool
+def get_entities_from_kg() -> list:
+    """
+    Loads a knowledge graph and returns a list of identified entity URIs.
+    Entities are typically resources with an rdf:type linking them to a class,
+    or those explicitly declared as owl:NamedIndividual.
+
+    Args:
+        graph_path (str): The path to the knowledge graph file (local path or URL).
+        format (str, optional): The format of the graph file (e.g., 'xml', 'turtle', 'json-ld').
+                                 If None, rdflib will try to guess the format based on the file extension.
+
+    Returns:
+        list: A list of rdflib.URIRef or rdflib.BNode objects representing the entities.
+    """
+    return []
+
+
+def parse_types_graph(g):
+    types = set()
+
+    # Query for classes defined using rdfs:Class
+    for s, p, o in g.triples((None, RDF.type, RDFS.Class)):
+        types.add(s)
+
+    # Query for classes defined using owl:Class
+    for s, p, o in g.triples((None, RDF.type, OWL.Class)):
+        types.add(s)
+
+    # You might also find classes as subjects of rdfs:subClassOf triples
+    # Although this doesn't strictly define a class, it implies the subject is a class
+    for s, p, o in g.triples((None, RDFS.subClassOf, None)):
+        types.add(s)
+        # Also add the object, as it must also be a class
+        if isinstance(o, term.URIRef) or isinstance(o, term.BNode):
+            types.add(o)
+
+    return sorted(list(types))
+
+
+def parse_relations_graph(g):
+    predicates = set()
+
+    # Query for resources explicitly typed as properties
+    property_types = [
+        RDF.Property,
+        OWL.ObjectProperty,
+        OWL.DatatypeProperty,
+        OWL.AnnotationProperty,
+    ]
+
+    for prop_type in property_types:
+        for s, p, o in g.triples((None, RDF.type, prop_type)):
+            predicates.add(s)
+
+    # Also consider any URI or BNode that is used as a predicate in any triple
+    # These are implicitly properties, even if not explicitly typed
+    for s, p, o in g.triples((None, None, None)):
+        if isinstance(p, term.URIRef) or isinstance(p, term.BNode):
+            predicates.add(p)
+
+    return sorted(list(predicates))
+
+
+@tool
+def get_types_from_ontology() -> list[URIRef]:
+    """
+    Loads an ontology and returns a list of defined class URIs.
+
+    Args:
+        ontology_path (str): The path to the ontology file (local path or URL).
+        format (str, optional): The format of the ontology file (e.g., 'xml', 'turtle', 'json-ld').
+                                 If None, rdflib will try to guess the format based on the file extension.
+
+    Returns:
+        list: A list of rdflib.URIRef objects representing the defined classes.
+    """
+    g = Graph()
+
+    try:
+        g.parse("./sources/cacao.owl", format=None)
+    except Exception as e:
+        print(f"Error loading ontology: {e}")
+        return []
+
+    return parse_types_graph(g)
+
+
+@tool
+def get_relations_from_ontology() -> list[URIRef]:
+    """
+    Loads an ontology and returns a list of defined predicate (property) URIs.
+
+    Args:
+        ontology_path (str): The path to the ontology file (local path or URL).
+        format (str, optional): The format of the ontology file (e.g., 'xml', 'turtle', 'json-ld').
+                                 If None, rdflib will try to guess the format based on the file extension.
+
+    Returns:
+        list: A list of rdflib.URIRef objects representing the defined predicates.
+    """
+    g = Graph()
+
+    try:
+        g.parse("./sources/cacao.owl", format=None)
+    except Exception as e:
+        print(f"Error loading ontology: {e}")
+        return []
+
+    return parse_relations_graph(g)