trustgraph-flow 0.13.2__tar.gz → 0.14.1__tar.gz

{trustgraph-flow-0.13.2 → trustgraph-flow-0.14.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: trustgraph-flow
-Version: 0.13.2
+Version: 0.14.1
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Home-page: https://github.com/trustgraph-ai/trustgraph
 Author: trustgraph.ai
 Author-email: security@trustgraph.ai
 License: UNKNOWN
-Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.13.2.tar.gz
+Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.14.1.tar.gz
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)

{trustgraph-flow-0.13.2 → trustgraph-flow-0.14.1}/setup.py

@@ -34,7 +34,7 @@ setuptools.setup(
     python_requires='>=3.8',
     download_url = "https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v" + version + ".tar.gz",
     install_requires=[
-        "trustgraph-base>=0.13,<0.14",
+        "trustgraph-base>=0.14,<0.15",
         "urllib3",
         "rdflib",
         "pymilvus",
@@ -56,6 +56,8 @@ setuptools.setup(
         "neo4j",
         "tiktoken",
         "google-generativeai",
+        "ibis",
+        "jsonschema",
     ],
     scripts=[
         "scripts/chunker-recursive",

trustgraph-flow-0.14.1/trustgraph/flow_version.py

@@ -0,0 +1 @@
+__version__ = "0.14.1"

trustgraph-flow-0.14.1/trustgraph/model/prompt/template/prompt_manager.py

@@ -0,0 +1,95 @@
+
+import ibis
+import json
+from jsonschema import validate
+import re
+
+from trustgraph.clients.llm_client import LlmClient
+
+class PromptConfiguration:
+    def __init__(self, system_template, global_terms={}, prompts={}):
+        self.system_template = system_template
+        self.global_terms = global_terms
+        self.prompts = prompts
+
+class Prompt:
+    def __init__(self, template, response_type = "text", terms=None, schema=None):
+        self.template = template
+        self.response_type = response_type
+        self.terms = terms
+        self.schema = schema
+
+class PromptManager:
+
+    def __init__(self, llm, config):
+        self.llm = llm
+        self.config = config
+        self.terms = config.global_terms
+
+        self.prompts = config.prompts
+
+        try:
+            self.system_template = ibis.Template(config.system_template)
+        except:
+            raise RuntimeError("Error in system template")
+
+        self.templates = {}
+        for k, v in self.prompts.items():
+            try:
+                self.templates[k] = ibis.Template(v.template)
+            except:
+                raise RuntimeError(f"Error in template: {k}")
+
+            if v.terms is None:
+                v.terms = {}
+
+    def parse_json(self, text):
+        json_match = re.search(r'```(?:json)?(.*?)```', text, re.DOTALL)
+    
+        if json_match:
+            json_str = json_match.group(1).strip()
+        else:
+            # If no delimiters, assume the entire output is JSON
+            json_str = text.strip()
+
+        return json.loads(json_str)
+
+    def invoke(self, id, input):
+
+        if id not in self.prompts:
+            raise RuntimeError("ID invalid")
+
+        terms = self.terms | self.prompts[id].terms | input
+
+        resp_type = self.prompts[id].response_type
+
+        prompt = {
+            "system": self.system_template.render(terms),
+            "prompt": self.templates[id].render(terms)
+        }
+
+        resp = self.llm.request(**prompt)
+
+        print(resp, flush=True)
+
+        if resp_type == "text":
+            return resp
+
+        if resp_type != "json":
+            raise RuntimeError(f"Response type {resp_type} not known")
+
+        try:
+            obj = self.parse_json(resp)
+        except:
+            raise RuntimeError("JSON parse fail")
+
+        print(obj, flush=True)
+        if self.prompts[id].schema:
+            try:
+                print(self.prompts[id].schema)
+                validate(instance=obj, schema=self.prompts[id].schema)
+            except Exception as e:
+                raise RuntimeError(f"Schema validation fail: {e}")
+
+        return obj
+

trustgraph-flow-0.14.1/trustgraph/model/prompt/template/service.py

@@ -0,0 +1,297 @@
+
+"""
+Language service abstracts prompt engineering from LLM.
+"""
+
+import json
+import re
+
+from .... schema import Definition, Relationship, Triple
+from .... schema import Topic
+from .... schema import PromptRequest, PromptResponse, Error
+from .... schema import TextCompletionRequest, TextCompletionResponse
+from .... schema import text_completion_request_queue
+from .... schema import text_completion_response_queue
+from .... schema import prompt_request_queue, prompt_response_queue
+from .... base import ConsumerProducer
+from .... clients.llm_client import LlmClient
+
+from . prompt_manager import PromptConfiguration, Prompt, PromptManager
+
+module = ".".join(__name__.split(".")[1:-1])
+
+default_input_queue = prompt_request_queue
+default_output_queue = prompt_response_queue
+default_subscriber = module
+
+class Processor(ConsumerProducer):
+
+    def __init__(self, **params):
+
+        prompt_base = {}
+
+        # Parsing the prompt information to the prompt configuration
+        # structure
+        prompt_arg = params.get("prompt", [])
+        if prompt_arg:
+            for p in prompt_arg:
+                toks = p.split("=", 1)
+                if len(toks) < 2:
+                    raise RuntimeError(f"Prompt string not well-formed: {p}")
+                prompt_base[toks[0]] = {
+                    "template": toks[1]
+                }
+
+        prompt_response_type_arg = params.get("prompt_response_type", [])
+        if prompt_response_type_arg:
+            for p in prompt_response_type_arg:
+                toks = p.split("=", 1)
+                if len(toks) < 2:
+                    raise RuntimeError(f"Response type not well-formed: {p}")
+                if toks[0] not in prompt_base:
+                    raise RuntimeError(f"Response-type, {toks[0]} not known")
+                prompt_base[toks[0]]["response_type"] = toks[1]
+
+        prompt_schema_arg = params.get("prompt_schema", [])
+        if prompt_schema_arg:
+            for p in prompt_schema_arg:
+                toks = p.split("=", 1)
+                if len(toks) < 2:
+                    raise RuntimeError(f"Schema arg not well-formed: {p}")
+                if toks[0] not in prompt_base:
+                    raise RuntimeError(f"Schema, {toks[0]} not known")
+                try:
+                    prompt_base[toks[0]]["schema"] = json.loads(toks[1])
+                except:
+                    raise RuntimeError(f"Failed to parse JSON schema: {p}")
+
+        prompt_term_arg = params.get("prompt_term", [])
+        if prompt_term_arg:
+            for p in prompt_term_arg:
+                toks = p.split("=", 1)
+                if len(toks) < 2:
+                    raise RuntimeError(f"Term arg not well-formed: {p}")
+                if toks[0] not in prompt_base:
+                    raise RuntimeError(f"Term, {toks[0]} not known")
+                kvtoks = toks[1].split(":", 1)
+                if len(kvtoks) < 2:
+                    raise RuntimeError(f"Term not well-formed: {toks[1]}")
+                k, v = kvtoks
+                if "terms" not in prompt_base[toks[0]]:
+                    prompt_base[toks[0]]["terms"] = {}
+                prompt_base[toks[0]]["terms"][k] = v
+
+        global_terms = {}
+
+        global_term_arg = params.get("global_term", [])
+        if global_term_arg:
+            for t in global_term_arg:
+                toks = t.split("=", 1)
+                if len(toks) < 2:
+                    raise RuntimeError(f"Global term arg not well-formed: {t}")
+                global_terms[toks[0]] = toks[1]
+
+        print(global_terms)
+
+        prompts = {
+            k: Prompt(**v)
+            for k, v in prompt_base.items()
+        }
+
+        prompt_configuration = PromptConfiguration(
+            system_template = params.get("system_prompt", ""),
+            global_terms = global_terms,
+            prompts = prompts
+        )
+
+        input_queue = params.get("input_queue", default_input_queue)
+        output_queue = params.get("output_queue", default_output_queue)
+        subscriber = params.get("subscriber", default_subscriber)
+        tc_request_queue = params.get(
+            "text_completion_request_queue", text_completion_request_queue
+        )
+        tc_response_queue = params.get(
+            "text_completion_response_queue", text_completion_response_queue
+        )
+        definition_template = params.get("definition_template")
+        relationship_template = params.get("relationship_template")
+        topic_template = params.get("topic_template")
+        rows_template = params.get("rows_template")
+        knowledge_query_template = params.get("knowledge_query_template")
+        document_query_template = params.get("document_query_template")
+
+        super(Processor, self).__init__(
+            **params | {
+                "input_queue": input_queue,
+                "output_queue": output_queue,
+                "subscriber": subscriber,
+                "input_schema": PromptRequest,
+                "output_schema": PromptResponse,
+                "text_completion_request_queue": tc_request_queue,
+                "text_completion_response_queue": tc_response_queue,
+            }
+        )
+
+        self.llm = LlmClient(
+            subscriber=subscriber,
+            input_queue=tc_request_queue,
+            output_queue=tc_response_queue,
+            pulsar_host = self.pulsar_host
+        )
+
+        # System prompt hack
+        class Llm:
+            def __init__(self, llm):
+                self.llm = llm
+            def request(self, system, prompt):
+                print(system)
+                print(prompt, flush=True)
+                return self.llm.request(system + "\n\n" + prompt)
+
+        self.llm = Llm(self.llm)
+
+        self.manager = PromptManager(
+            llm = self.llm,
+            config = prompt_configuration,
+        )
+
+    def handle(self, msg):
+
+        v = msg.value()
+
+        # Sender-produced ID
+
+        id = msg.properties()["id"]
+
+        kind = v.id
+
+        try:
+
+            print(v.terms)
+
+            input = {
+                k: json.loads(v)
+                for k, v in v.terms.items()
+            }
+            
+            print(f"Handling kind {kind}...", flush=True)
+            print(input, flush=True)
+
+            resp = self.manager.invoke(kind, input)
+
+            if isinstance(resp, str):
+
+                print("Send text response...", flush=True)
+                print(resp, flush=True)
+
+                r = PromptResponse(
+                    text=resp,
+                    object=None,
+                    error=None,
+                )
+
+                self.producer.send(r, properties={"id": id})
+
+                return
+
+            else:
+
+                print("Send object response...", flush=True)
+                print(json.dumps(resp, indent=4), flush=True)
+
+                r = PromptResponse(
+                    text=None,
+                    object=json.dumps(resp),
+                    error=None,
+                )
+
+                self.producer.send(r, properties={"id": id})
+
+                return
+            
+        except Exception as e:
+
+            print(f"Exception: {e}")
+
+            print("Send error response...", flush=True)
+
+            r = PromptResponse(
+                error=Error(
+                    type = "llm-error",
+                    message = str(e),
+                ),
+                response=None,
+            )
+
+            self.producer.send(r, properties={"id": id})
+
+        except Exception as e:
+
+            print(f"Exception: {e}")
+
+            print("Send error response...", flush=True)
+
+            r = PromptResponse(
+                error=Error(
+                    type = "llm-error",
+                    message = str(e),
+                ),
+                response=None,
+            )
+
+            self.producer.send(r, properties={"id": id})
+
+    @staticmethod
+    def add_args(parser):
+
+        ConsumerProducer.add_args(
+            parser, default_input_queue, default_subscriber,
+            default_output_queue,
+        )
+
+        parser.add_argument(
+            '--text-completion-request-queue',
+            default=text_completion_request_queue,
+            help=f'Text completion request queue (default: {text_completion_request_queue})',
+        )
+
+        parser.add_argument(
+            '--text-completion-response-queue',
+            default=text_completion_response_queue,
+            help=f'Text completion response queue (default: {text_completion_response_queue})',
+        )
+
+        parser.add_argument(
+            '--prompt', nargs='*',
+            help=f'Prompt template form id=template',
+        )
+
+        parser.add_argument(
+            '--prompt-response-type', nargs='*',
+            help=f'Prompt response type, form id=json|text',
+        )
+
+        parser.add_argument(
+            '--prompt-term', nargs='*',
+            help=f'Prompt response type, form id=key:value',
+        )
+
+        parser.add_argument(
+            '--prompt-schema', nargs='*',
+            help=f'Prompt response schema, form id=schema',
+        )
+
+        parser.add_argument(
+            '--system-prompt',
+            help=f'System prompt template',
+        )
+
+        parser.add_argument(
+            '--global-term', nargs='+',
+            help=f'Global term, form key:value'
+        )
+
+def run():
+
+    Processor.start(module, __doc__)
+

{trustgraph-flow-0.13.2 → trustgraph-flow-0.14.1}/trustgraph_flow.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: trustgraph-flow
-Version: 0.13.2
+Version: 0.14.1
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Home-page: https://github.com/trustgraph-ai/trustgraph
 Author: trustgraph.ai
 Author-email: security@trustgraph.ai
 License: UNKNOWN
-Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.13.2.tar.gz
+Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.14.1.tar.gz
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)

{trustgraph-flow-0.13.2 → trustgraph-flow-0.14.1}/trustgraph_flow.egg-info/SOURCES.txt

@@ -91,7 +91,7 @@ trustgraph/model/prompt/generic/prompts.py
 trustgraph/model/prompt/generic/service.py
 trustgraph/model/prompt/template/__init__.py
 trustgraph/model/prompt/template/__main__.py
-trustgraph/model/prompt/template/prompts.py
+trustgraph/model/prompt/template/prompt_manager.py
 trustgraph/model/prompt/template/service.py
 trustgraph/model/text_completion/__init__.py
 trustgraph/model/text_completion/azure/__init__.py

{trustgraph-flow-0.13.2 → trustgraph-flow-0.14.1}/trustgraph_flow.egg-info/requires.txt

@@ -2,6 +2,8 @@ anthropic
 cassandra-driver
 cohere
 google-generativeai
+ibis
+jsonschema
 langchain
 langchain-community
 langchain-core
@@ -18,5 +20,5 @@ rdflib
 requests
 tabulate
 tiktoken
-trustgraph-base<0.14,>=0.13
+trustgraph-base<0.15,>=0.14
 urllib3

trustgraph-flow-0.13.2/trustgraph/flow_version.py

@@ -1 +0,0 @@
-__version__ = "0.13.2"

trustgraph-flow-0.13.2/trustgraph/model/prompt/template/prompts.py

@@ -1,47 +0,0 @@
-
-def to_relationships(template, text):
-    return template.format(text=text)
-    
-def to_definitions(template, text):
-    return template.format(text=text)
-
-def to_topics(template, text):
-    return template.format(text=text)
-
-def to_rows(template, schema, text):
-
-    field_schema = [
-        f"- Name: {f.name}\n  Type: {f.type}\n  Definition: {f.description}"
-        for f in schema.fields
-    ]
-
-    field_schema = "\n".join(field_schema)
-
-    return template.format(schema=schema, text=text)
-
-    schema = f"""Object name: {schema.name}
-Description: {schema.description}
-
-Fields:
-{schema}"""
-
-    prompt = f""""""
-    
-    return prompt
-    
-def get_cypher(kg):
-    sg2 = []
-    for f in kg:
-        sg2.append(f"({f.s})-[{f.p}]->({f.o})")
-    kg = "\n".join(sg2)
-    kg = kg.replace("\\", "-")
-    return kg
-
-def to_kg_query(template, query, kg):
-    cypher =  get_cypher(kg)
-    return template.format(query=query, graph=cypher)
-
-def to_document_query(template, query, docs):
-    docs = "\n\n".join(docs)
-    return template.format(query=query, documents=docs)
-