first stab

Author: hrshdhgd

poetry.lock

@@ -11,6 +11,12 @@ python = "^3.9"
 click = "*"
 importlib-metadata = ">=8.2.0"
 langchain = "^0.2.12"
+langchain-openai = "^0.1.22"
+langchain-community = "^0.2.11"
+kgcl-schema = "^0.6.8"
+langchain-ollama = "^0.1.1"
+langchain-anthropic = "^0.1.22"
+langchain-chroma = "^0.1.3"
 
 [tool.poetry.group.dev.dependencies]
 pytest = {version = ">=8.3.2"}

pyproject.toml

@@ -5,7 +5,17 @@
 import click
 
 from llm_change_agent import __version__
-from llm_change_agent.main import demo
+from llm_change_agent.constants import OPEN_AI_MODEL
+from llm_change_agent.llm_agent import LLMChangeAgent
+from llm_change_agent.utils.llm_utils import (
+    get_anthropic_models,
+    get_lbl_cborg_models,
+    get_ollama_models,
+    get_openai_models,
+)
+
+ALL_AVAILABLE_PROVIDERS = ["openai", "ollama", "anthropic", "cborg"]
+ALL_AVAILABLE_MODELS = get_openai_models() + get_ollama_models() + get_anthropic_models() + get_lbl_cborg_models()
 
 __all__ = [
     "main",
@@ -36,9 +46,31 @@ def main(verbose: int, quiet: bool):
 
 
 @main.command()
-def run():
-    """Run the llm-change-agent's demo command."""
-    demo()
+def list_models():
+    """List the available language models."""
+    openai_models = "\n  ".join(get_openai_models())
+    anthropic_models = "\n  ".join(get_anthropic_models())
+    ollama_models = "\n  ".join(get_ollama_models())
+    lbl_cborg_models = "\n  ".join(get_lbl_cborg_models())
+
+    click.echo(f"OpenAI models:\n  {openai_models}")
+    click.echo(f"Anthropic models:\n  {anthropic_models}")
+    click.echo(f"Ollama models:\n  {ollama_models}")
+    click.echo(f"LBL-CBORG models:\n  {lbl_cborg_models}")
+
+
+@main.command()
+@click.option(
+    "--model", type=click.Choice(ALL_AVAILABLE_MODELS), default=OPEN_AI_MODEL, help="Model to use for generation."
+)
+@click.option(
+    "--provider", type=click.Choice(ALL_AVAILABLE_PROVIDERS), default="openai", help="Provider to use for generation."
+)
+@click.option("--prompt", type=str, default="Hello, world!", help="Prompt to use for generation.")
+def generate(model: str, provider: str, prompt: str):
+    """Generate text using the specified model."""
+    llm_agent = LLMChangeAgent(model=model, prompt=prompt, provider=provider)
+    llm_agent.run()
 
 
 if __name__ == "__main__":

src/llm_change_agent/cli.py

@@ -0,0 +1,36 @@
+"""Configuration classes for the LLM models."""
+
+from pydantic import BaseModel
+
+
+class LLMConfig(BaseModel):
+    """Configuration for the LLM model."""
+
+    model: str
+    provider: str
+    temperature: float = 0.0
+
+
+class OpenAIConfig(LLMConfig):
+    """Configuration for OpenAI LLM model."""
+
+    pass
+
+
+class OllamaConfig(LLMConfig):
+    """Configuration for Ollama LLM model."""
+
+    format: str = None
+    pass
+
+
+class AnthropicConfig(LLMConfig):
+    """Configuration for Anthropic LLM model."""
+
+    pass
+
+
+class CBORGConfig(LLMConfig):
+    """Configuration for CBORG LLM model."""
+
+    base_url: str = "https://api.cborg.lbl.gov"  # Local clients can also use https://api-local.cborg.lbl.gov

src/llm_change_agent/config/llm_config.py

@@ -0,0 +1,17 @@
+"""Constants for the LLM Change Agent."""
+
+from os import getenv
+
+from importlib_metadata import files
+
+OPENAI_KEY = str(getenv("OPENAI_API_KEY"))
+ANTHROPIC_KEY = str(getenv("ANTHROPIC_API_KEY"))
+CBORG_KEY = str(getenv("CBORG_API_KEY"))
+
+OPEN_AI_MODEL = "gpt-4o-mini"
+ANTHROPIC_MODEL = "claude-3-5-sonnet-20240620"
+OLLAMA_MODEL = "llama3.1"  #!  not all models support tools (tool calling)
+CBORG_MODEL = "lbl/llama-3"
+
+KGCL_SCHEMA = [file for file in files("kgcl-schema") if file.stem == "kgcl" and file.suffix == ".yaml"][0]
+KGCL_GRAMMAR = [file for file in files("kgcl-schema") if file.stem == "kgcl" and file.suffix == ".lark"][0]

src/llm_change_agent/constants.py

@@ -0,0 +1,88 @@
+"""Main python file."""
+
+from pprint import pprint
+
+from llm_change_agent.constants import OPEN_AI_MODEL
+from llm_change_agent.utils.llm_utils import (
+    execute_agent,
+    get_anthropic_models,
+    get_lbl_cborg_models,
+    get_ollama_models,
+    get_openai_models,
+    get_provider_for_model,
+    get_provider_model_map,
+    llm_factory,
+)
+
+
+class LLMChangeAgent:
+    """Define LLMChangeAgent class."""
+
+    def __init__(self, model: str, prompt: str, provider: str):
+        """Initialize LLMChangeAgent class."""
+        self.model = model
+        self.prompt = prompt
+        self.provider = provider
+        self.llm = None
+
+    def _get_llm_config(self):
+        """Get the LLM configuration based on the selected LLM."""
+
+        def _validate_and_get_model(llm_model, get_models_func, default_model=OPEN_AI_MODEL):
+            """Validate the model and get the model."""
+            if llm_model is None:
+                return OpenAIConfig(model=default_model, provider=get_provider_for_model(llm_model))
+            list_of_models = get_models_func()
+            if llm_model not in list_of_models:
+                raise ValueError(f"Model {llm_model} not supported. Please choose from {list_of_models}")
+            return llm_model
+
+        if self.provider == "openai":
+            from .config.llm_config import OpenAIConfig
+
+            llm_model = _validate_and_get_model(self.model, get_openai_models)
+            return OpenAIConfig(model=llm_model, provider=get_provider_for_model(llm_model))
+
+        elif self.provider == "ollama":
+            from .config.llm_config import OllamaConfig
+
+            llm_model = _validate_and_get_model(self.model, get_ollama_models)
+            return OllamaConfig(model=llm_model)
+
+        elif self.provider == "anthropic":
+            from .config.llm_config import AnthropicConfig
+
+            llm_model = _validate_and_get_model(self.model, get_anthropic_models)
+            return AnthropicConfig(model=llm_model, provider=get_provider_for_model(llm_model))
+
+        elif self.provider == "cborg":
+            from .config.llm_config import CBORGConfig
+
+            llm_model = _validate_and_get_model(self.model, get_lbl_cborg_models)
+            return CBORGConfig(model=llm_model, provider=get_provider_for_model(llm_model))
+
+        else:
+            all_models = get_provider_model_map()
+            if llm_model is None:
+                llm_model = OPEN_AI_MODEL
+                from .config.llm_config import OpenAIConfig
+
+                return OpenAIConfig(model=llm_model, provider=get_provider_for_model(llm_model))
+
+            for provider, models in all_models.items():
+                if llm_model in models:
+                    return self._get_llm_config(provider, llm_model)
+
+            raise ValueError(f"Model {llm_model} not supported.")
+
+    def run(self):
+        """Run the LLM Change Agent."""
+        llm_config = self._get_llm_config()
+        self.prompt = """
+        Add a new exact synonym gastric cancer for MONDO_0001056.
+        """
+        new_prompt = "Give me all relevant KGCL commands based on this request: " + self.prompt
+        self.llm = llm_factory(llm_config)
+        response = execute_agent(llm=self.llm, prompt=new_prompt)
+        pprint(response["output"])
+        return response["output"]

src/llm_change_agent/llm_agent.py

@@ -0,0 +1,101 @@
+"""Templates for the LLM Change Agent."""
+
+from langchain_core.prompts.prompt import PromptTemplate
+
+
+def get_issue_analyzer_template():
+    """Issue analyzer template."""
+    template = """
+        {input}
+        You are an semantic engineer. Based on the text you are given,
+        you will analyze it and categorize the text into categories.
+        The different categories along with their description are provided by the
+        following LinkML schema:
+        {schema}
+        All that is expected of you is to categorize the text into one of the above categories and
+        form relevant KGCL commands in a list.
+        You have the following tools at your disposal to help you with this task:
+        {tools}
+        You also have the grammar in lark format: {grammar} along with an explanation of the grammar: {explanation}
+        I want NO verbosity in your response. The final answer should be a dictionary with the category
+        as key an command or list of commands as value.
+
+        Use the following format:
+
+            Question: the input question you must answer
+            Thought: you should always think about what to do
+            Action: the action to take, should be one of [{tool_names}]
+            Action Input: the input to the action
+            Observation: the result of the action
+            ... (this Thought/Action/Action Input/Observation can repeat N times)
+            Thought: I now know the final answer
+            Final Answer: the final answer to the original input question
+
+            Begin!
+
+            Question: {input}
+            Thought:{agent_scratchpad}
+    """
+    return PromptTemplate(
+        input_variables=[
+            "input",
+            "agent_scratchpad",
+            "tools",
+            "tool_names",
+            "intermediate_steps",
+            "schema",
+            "grammar",
+            "explanation",
+        ],
+        template=template,
+    )
+
+
+def grammar_explanation():
+    """Grammar explanation template."""
+    return """
+    The grammar defines commands for various operations such as renaming, creating, deleting, and modifying entities. It includes the following components:
+
+    - `expression`: The entry point of the grammar, which can be any of the defined commands like `rename`, `create`, `delete`, etc.
+
+    - `rename`: This command follows the pattern `"rename" _WS [id _WS "from" _WS] old_label ["@" old_language] _WS ("to"|"as"|"->") _WS new_label ["@" new_language]`.
+
+    - `create`: This command follows the pattern `"create node" _WS id _WS label ["@" language]`.
+
+    - `create_class`: This command follows the pattern `"create" _WS id`.
+
+    - `create_synonym`: This command follows the pattern `"create" _WS [synonym_qualifier _WS] "synonym" _WS synonym ["@" language] _WS "for" _WS entity`.
+
+    - `delete`: This command follows the pattern `"delete" _WS entity`.
+
+    - `obsolete`: This command follows the pattern `"obsolete" _WS entity` or `"obsolete" _WS entity _WS "with replacement" _WS replacement`.
+
+    - `unobsolete`: This command follows the pattern `"unobsolete" _WS entity`.
+
+    - `deepen`: This command follows the pattern `"deepen" _WS entity _WS "from" _WS old_entity _WS ("to"|"->") _WS new_entity`.
+
+    - `shallow`: This command follows the pattern `"shallow" _WS entity _WS "from" _WS old_entity _WS ("to"|"->") _WS new_entity`.
+
+    - `move`: This command follows the pattern `"move" _WS entity_subject _WS entity_predicate _WS entity_object _WS "from" _WS old_entity _WS ("to"|"as"|"->") _WS new_entity`.
+
+    - `create_edge`: This command follows the pattern `"create edge" _WS entity_subject _WS entity_predicate _WS entity_object_id`.
+
+    - `delete_edge`: This command follows the pattern `"delete edge" _WS entity_subject _WS entity_predicate _WS entity_object_id`.
+
+    - `change_relationship`: This command follows the pattern `"change relationship between" _WS entity_subject _WS "and" _WS entity_object _WS "from" _WS old_entity _WS "to" _WS new_entity`.
+
+    - `change_annotation`: This command follows the pattern `"change annotation of" _WS entity_subject _WS "with" _WS entity_predicate _WS "from" _WS old_entity_object _WS "to" _WS new_entity_object`.
+
+    - `change_definition`: This command follows the pattern `"change definition of" _WS entity _WS "to" _WS new_definition` or `"change definition of" _WS entity _WS "from" _WS old_definition _WS "to" _WS new_definition`.
+
+    - `add_definition`: This command follows the pattern `"add definition" _WS new_definition _WS "to" _WS entity`.
+
+    - `remove_definition`: This command follows the pattern `"remove definition for" _WS entity`.
+
+    - `remove_from_subset`: This command follows the pattern `"remove" _WS id _WS "from subset" _WS subset`.
+
+    - `add_to_subset`: This command follows the pattern `"add" _WS id _WS "to subset" _WS subset`.
+
+    The `%import` statements import common definitions for `ID`, `LABEL`, `CURIE`, `SINGLE_QUOTE_LITERAL`, `TRIPLE_SINGLE_QUOTE_LITERAL`, `DOUBLE_QUOTE_LITERAL`, `TRIPLE_DOUBLE_QUOTE_LITERAL`, `LANGUAGE_TAG`, and whitespace (`_WS`). The `%ignore` statement tells the parser to ignore whitespace.
+
+    """