dhti-elixir-base 0.1.0__py3-none-any.whl

dhti_elixir_base/__init__.py

@@ -0,0 +1,27 @@
+import sys
+
+from .agent import BaseAgent
+from .chain import BaseChain
+from .graph import BaseGraph
+from .llm import BaseLLM
+from .model import BaseModel
+from .server import BaseServer
+from .space import BaseSpace
+from .mydi import get_di
+
+if sys.version_info[:2] >= (3, 8):
+    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
+    from importlib.metadata import PackageNotFoundError, version  # pragma: no cover
+else:
+    from importlib_metadata import PackageNotFoundError, version  # pragma: no cover
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = __name__
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError
+
+__all__ = ["chain"]

dhti_elixir_base/agent.py

@@ -0,0 +1,202 @@
+"""
+Copyright 2023 Bell Eapen
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import re
+from typing import List, Dict
+
+from langchain.agents import AgentType, initialize_agent, AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, Field, ConfigDict
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+
+from .mydi import get_di
+
+
+# from langchain_core.prompts import MessagesPlaceholder
+# from langchain.memory.buffer import ConversationBufferMemory
+class BaseAgent:
+
+    class AgentInput(BaseModel):
+        """Chat history with the bot."""
+        input: str
+        model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
+
+    def __init__(
+        self,
+        name=None,
+        description=None,
+        llm=None,
+        input_type: type[BaseModel] | None = None,
+        prefix=None,
+        suffix=None,
+        tools: List = [],
+        mcp = None,
+    ):
+        self.llm = llm or get_di("function_llm")
+        self.prefix = prefix or get_di("prefix")
+        self.suffix = suffix or get_di("suffix")
+        self.tools = tools
+        self._name = (
+            name or re.sub(r"(?<!^)(?=[A-Z])", "_", self.__class__.__name__).lower()
+        )
+        self._description = description or f"Agent for {self._name}"
+        # current_patient_context = MessagesPlaceholder(variable_name="current_patient_context")
+        # memory = ConversationBufferMemory(memory_key="current_patient_context", return_messages=True)
+        self.agent_kwargs = {
+            "prefix": self.prefix,
+            "suffix": self.suffix,
+            # "memory_prompts": [current_patient_context],
+            "input_variables": ["input", "agent_scratchpad", "current_patient_context"],
+        }
+        if input_type is None:
+            self.input_type = self.AgentInput
+        else:
+            self.input_type = input_type
+        if mcp is not None:
+            self.client = MultiServerMCPClient(mcp)
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def description(self):
+        return self._description
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @description.setter
+    def description(self, value):
+        self._description = value
+
+    def get_agent(self):
+        if self.llm is None:
+            raise ValueError("llm must not be None when initializing the agent.")
+        return initialize_agent(
+            tools=self.tools,
+            llm=self.llm,
+            agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
+            stop=["\nObservation:"],
+            max_iterations=len(self.tools) + 3,
+            handle_parsing_errors=True,
+            agent_kwargs=self.agent_kwargs,
+            verbose=True,
+        ).with_types(
+            input_type=self.input_type # type: ignore
+        )
+
+    # ! This is currently supported only for models supporting llm.bind_tools. See function return
+    def get_agent_prompt(self):
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "{prefix}"
+                    " You have access to the following tools: {tool_names}.\n{system_message}",
+                ),
+                MessagesPlaceholder(variable_name="messages"),
+            ]
+        )
+        prompt = prompt.partial(prefix=self.prefix)
+        prompt = prompt.partial(system_message=self.suffix)
+        prompt = prompt.partial(
+            tool_names=", ".join([tool.name for tool in self.tools])
+        )
+        return prompt
+
+    def get_agent_chat_prompt_with_memory(self):
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", "You are a helpful assistant."),
+                # First put the history
+                ("placeholder", "{chat_history}"),
+                # Then the new input
+                ("human", "{input}"),
+                # Finally the scratchpad
+                ("placeholder", "{agent_scratchpad}"),
+            ]
+        )
+
+    def langgraph_agent(self):
+        """Create an agent."""
+        prompt = self.get_agent_prompt()
+        if not hasattr(self.llm, "bind_tools"):
+            raise ValueError(
+                "The LLM does not support binding tools. Please use a compatible LLM."
+            )
+        return prompt | self.llm.bind_tools(self.tools)  # type: ignore
+
+    def get_langgraph_agent_executor(self):
+        """Get the agent executor."""
+        if self.llm is None:
+            raise ValueError("llm must not be None when initializing the agent executor.")
+        agent = create_tool_calling_agent(
+            llm=self.llm,
+            tools=self.tools,
+            prompt=self.get_agent_prompt(),
+        )
+        agent_executor = AgentExecutor(agent=agent, tools=self.tools)
+        return agent_executor
+
+    def get_langgraph_agent_executor_with_memory(self):
+        from langchain_core.chat_history import InMemoryChatMessageHistory
+        from langchain_core.runnables.history import RunnableWithMessageHistory
+        if self.llm is None:
+            raise ValueError(
+                "llm must not be None when initializing the agent executor."
+            )
+        memory = InMemoryChatMessageHistory()
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", "You are a helpful assistant."),
+                # First put the history
+                ("placeholder", "{chat_history}"),
+                # Then the new input
+                ("human", "{input}"),
+                # Finally the scratchpad
+                ("placeholder", "{agent_scratchpad}"),
+            ]
+        )
+        agent = create_tool_calling_agent(
+            llm=self.llm,
+            tools=self.tools,
+            prompt=prompt,
+        )
+        agent_executor = AgentExecutor(agent=agent, tools=self.tools)
+        return RunnableWithMessageHistory(
+            agent_executor,  # type: ignore
+            # This is needed because in most real world scenarios, a session id is needed
+            # It isn't really used here because we are using a simple in memory ChatMessageHistory
+            lambda session_id: memory,
+            input_messages_key="input",
+            history_messages_key="chat_history",
+        )
+
+    async def get_langgraph_mcp_agent(self):
+        """Get the agent executor for async execution."""
+        if self.llm is None:
+            raise ValueError("llm must not be None when initializing the agent executor.")
+        if self.client is None:
+            raise ValueError("MCP client must not be None when initializing the agent.")
+        tools = await self.client.get_tools()
+        agent = create_react_agent(
+            model=self.llm,
+            tools=tools,
+        )
+        return agent

dhti_elixir_base/chain.py

@@ -0,0 +1,178 @@
+import re
+
+from kink import inject
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+from pydantic import BaseModel, ConfigDict
+
+from .mydi import get_di
+
+
+@inject
+class BaseChain:
+
+    class ChainInput(BaseModel):
+        question: str
+        model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
+
+    def __init__(
+        self,
+        chain=None,
+        prompt={},
+        name=None,
+        description=None,
+        main_llm=None,
+        clinical_llm=None,
+        grounding_llm=None,
+        input_type=None,
+        output_type=None,
+    ):
+        self._chain = chain
+        self._prompt = prompt or get_di("main_prompt")
+        self._main_llm = main_llm or get_di("base_main_llm")
+        self._clinical_llm = clinical_llm or get_di("base_clinical_llm")
+        self._grounding_llm = grounding_llm or get_di("base_grounding_llm")
+        self._input_type = input_type or self.ChainInput
+        self._output_type = output_type
+        self._name = name
+        self._description = description
+        self.init_prompt()
+
+    @property
+    def chain(self):
+        if self._chain is None:
+            """Get the runnable chain."""
+            """ RunnableParallel / RunnablePassthrough / RunnableSequential / RunnableLambda / RunnableMap / RunnableBranch """
+            if self.prompt is None:
+                raise ValueError("Prompt must not be None when building the chain.")
+            _sequential = (
+                RunnablePassthrough()
+                | self.prompt # "{input}""
+                | self.main_llm
+                | StrOutputParser()
+            )
+            chain = _sequential.with_types(input_type=self.input_type)
+            return chain
+
+    @property
+    def prompt(self):
+        return self._prompt
+
+    @property
+    def main_llm(self):
+        if self._main_llm is None:
+            self._main_llm = get_di("base_main_llm")
+        return self._main_llm
+
+    @property
+    def clinical_llm(self):
+        if self._clinical_llm is None:
+            self._clinical_llm = get_di("base_clinical_llm")
+        return self._clinical_llm
+
+    @property
+    def grounding_llm(self):
+        if self._grounding_llm is None:
+            self._grounding_llm = get_di("base_grounding_llm")
+        return self._grounding_llm
+
+    @property
+    def input_type(self):
+        if self._input_type is None:
+            self._input_type = self.ChainInput
+        return self._input_type
+
+    @property
+    def output_type(self):
+        return self._output_type
+
+    @property
+    def name(self):
+        if self._name is None:
+            return re.sub(r"(?<!^)(?=[A-Z])", "_", self.__class__.__name__).lower()
+
+    @property
+    def description(self):
+        if self._description is None:
+            self._description = f"Chain for {self.name}"
+        return self._description
+
+    @chain.setter
+    def chain(self, value):
+        self._chain = value
+
+    @prompt.setter
+    def prompt(self, value):
+        self._prompt = value
+        self.init_prompt()
+
+    @main_llm.setter
+    def main_llm(self, value):
+        self._main_llm = value
+
+    @clinical_llm.setter
+    def clinical_llm(self, value):
+        self._clinical_llm = value
+
+    @grounding_llm.setter
+    def grounding_llm(self, value):
+        self._grounding_llm = value
+
+    @input_type.setter
+    def input_type(self, value):
+        self._input_type = value
+
+    @output_type.setter
+    def output_type(self, value):
+        self._output_type = value
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @description.setter
+    def description(self, value):
+        self._description = value
+
+    def invoke(self, **kwargs):
+        if self.chain is None:
+            raise ValueError("Chain is not initialized.")
+        return self.chain.invoke(kwargs)
+
+    def __call__(self, **kwargs):
+        return self.invoke(**kwargs)
+
+    @DeprecationWarning
+    def get_runnable(self, **kwargs):
+        return self.chain
+
+    # * Override these methods in subclasses
+    def init_prompt(self):
+        pass
+
+    def generate_llm_config(self):
+        _input_schema = self.input_type.schema()
+        function_schema = {
+            "name": (self.name or self.__class__.__name__).lower().replace(" ", "_"),
+            "description": self.description,
+            "parameters": {
+                "type": _input_schema["type"],
+                "properties": _input_schema["properties"],
+                "required": _input_schema["required"],
+            },
+        }
+        return function_schema
+
+
+# # Named chain according to the langchain template convention
+# # The description is used by the agents
+#! This is only in the inherited class, not in the base class here.
+# @tool(BaseChain().name or "test_chain", args_schema=BaseChain().input_type)
+# def chain(**kwargs):
+#     """
+#     This is a template chain that takes a text input and returns a summary of the text.
+
+#     The input is a dict with the following mandatory keys:
+#         input (str): The text to summarize.
+#     """
+#     return BaseChain().chain.invoke(kwargs)

dhti_elixir_base/graph.py

@@ -0,0 +1,165 @@
+"""
+Copyright 2024 Bell Eapen
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import functools
+import operator
+import re
+from typing import Annotated, Literal, Sequence, TypedDict
+from kink import inject, di
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, ToolMessage
+from langgraph.graph import END, StateGraph
+
+
+"""_summary_
+
+    Helper class to add multi-agent support with langgraph.
+    The agents can be BaseAgent derived classes and support VertexAI.
+"""
+
+
+@inject
+class BaseGraph:
+    # Ref 1: https://github.com/langchain-ai/langgraph/blob/main/examples/multi_agent/multi-agent-collaboration.ipynb
+    # Ref 2: https://medium.com/@cplog/introduction-to-langgraph-a-beginners-guide-14f9be027141
+    # * call_tools = tool_node [ToolNode is currently not supported by VertexAI because of the lack of llm.bind_tools()]
+    # ! Tools are handled by the respective agents
+    class AgentState(TypedDict):
+        messages: Annotated[Sequence[BaseMessage], operator.add]
+        sender: str
+
+    def __init__(
+        self,
+        agents=[],  # required
+        edges=[],  # [{"from": "agent1", "to": "agent2", "conditional": True, "router": "default"}, {"from": "agent2", "to": "agent1", "conditional": True, "router": "default"}] #required
+        entry_point="",  # required agent_1
+        ends=[],  # optional
+        end_words=[],  # optional ["exit", "quit", "bye", "sorry", "final"] The words that will trigger the end of the conversation
+        agent_state=None,  # optional default AgentState above
+        nodes=None,  # optional, generated
+        workflow=None,  # optional, generated
+        name=None,  # optional, generated
+        recursion_limit=15,  # optional, default
+    ):
+        self.agents = agents
+        self.edges = edges
+        self.end_words = end_words
+        self.nodes = nodes
+        self.workflow = workflow
+        self.entry_point = entry_point
+        self.agent_state = agent_state or self.AgentState
+        self.ends = ends
+        self.recursion_limit = recursion_limit
+        self._name = name
+
+    def init_graph(self):
+        # We create a workflow that will be used to manage the state of the agents
+        if self.workflow is None:
+            self.workflow = StateGraph(self.agent_state)
+        # We create the nodes for each agent
+        if self.nodes is None:
+            self.nodes = []
+            for agent in self.agents:
+                self.nodes.append(self.agent_node(agent))
+        # We add the nodes to the workflow
+        for node, agent in zip(self.nodes, self.agents):
+            self.workflow.add_node(agent.name, node)
+        # We set the entry point of the workflow
+        self.workflow.set_entry_point(self.entry_point)
+        # We set the end points of the workflow
+        for end in self.ends:
+            self.workflow.add_edge(end, END)
+        # Add  edges
+        for edge in self.edges:
+            if edge["conditional"]:
+                if edge["router"] == "default":
+                    _router = self.router
+                else:
+                    _router = di[
+                        edge["router"]
+                    ]  # This is a dependency injection of router if needed
+                self.workflow.add_conditional_edges(
+                    edge["from"],
+                    _router,
+                    {"continue": edge["to"], "__end__": END},
+                )
+            else:
+                self.workflow.add_edge(edge["from"], edge["to"])
+        self.graph = self.workflow.compile()
+
+    @property
+    def name(self):
+        if self._name:
+            return self._name
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.__class__.__name__).lower()
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    # Helper function to create a node for a given agent
+    @staticmethod
+    def create_agent_node(state, agent):
+        _result = None
+        try:
+            result = agent.invoke(state)
+        except ValueError as e:
+            _result = agent.invoke({"input": state})
+            result = _result["input"]["messages"][0]
+
+        if _result is not None and "output" in _result:
+            result = ToolMessage(content=_result["output"], tool_call_id="myTool")
+        # We convert the agent output into a format that is suitable to append to the global state
+        if isinstance(result, ToolMessage):
+            pass
+        else:
+            try:
+                result = AIMessage(
+                    **result.dict(exclude={"type", "name"}), name=agent.name
+                )
+            except Exception as e:
+                result = AIMessage(content=result.content, name=agent.name)
+        return {
+            "messages": [result],  # Yes, this should be an array!
+            "sender": agent.name,
+            # * Return other state variables if any
+        }
+
+    def agent_node(self, agent):
+        return functools.partial(self.create_agent_node, agent=agent)
+
+    def router(self, state) -> Literal["__end__", "continue"]:
+        # This is the default router
+        messages = state["messages"]
+        last_message = messages[-1]
+        if any(
+            [exit.lower() in last_message.content.lower() for exit in self.end_words]
+        ):
+            return "__end__"
+        return "continue"
+
+    def invoke(self, message):
+        events = self.graph.stream(
+            {
+                "messages": [
+                    HumanMessage(
+                        content=message,
+                    )
+                ],
+            },
+            # Maximum number of steps to take in the graph
+            {"recursion_limit": self.recursion_limit},
+        )
+        return events

dhti_elixir_base/llm.py

@@ -0,0 +1,79 @@
+from abc import abstractmethod
+from typing import Any, List, Mapping, Optional
+
+from langchain.llms.base import LLM
+from pydantic import Field
+
+
+class BaseLLM(LLM):
+
+    hosted_url: Optional[str] = Field(
+        None, alias="hosted_url"
+    )  #! Alias is important when inheriting from LLM
+    model_name: Optional[str] = Field(None, alias="model_name")
+    params: Mapping[str, Any] = Field(default_factory=dict, alias="params")
+
+    backend: Optional[str] = "dhti"
+    temperature: Optional[float] = 0.1
+    top_p: Optional[float] = 0.8
+    top_k: Optional[int] = 40
+    n_batch: Optional[int] = 8
+    n_threads: Optional[int] = 4
+    n_predict: Optional[int] = 256
+    max_output_tokens: Optional[int] = 512
+    repeat_last_n: Optional[int] = 64
+    repeat_penalty: Optional[float] = 1.18
+
+    def __init__(self, hosted_url: str, model_name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.hosted_url = hosted_url
+        self.model_name = model_name
+        self.params = {**self._get_model_default_parameters, **kwargs}
+
+    @property
+    def _get_model_default_parameters(self):
+        return {
+            "max_output_tokens": self.max_output_tokens,
+            "n_predict": self.n_predict,
+            "top_k": self.top_k,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "n_batch": self.n_batch,
+            "repeat_penalty": self.repeat_penalty,
+            "repeat_last_n": self.repeat_last_n,
+        }
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """
+        Get all the identifying parameters
+        """
+        return {
+            "model_name": self.model_name,
+            "hosted_url": self.hosted_url,
+            "model_parameters": self._get_model_default_parameters,
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        return "dhti"
+
+    @abstractmethod
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[Any] = None,
+        **kwargs
+    ) -> str:
+        """
+        Args:
+            prompt: The prompt to pass into the model.
+            stop: A list of strings to stop generation when encountered
+            run_manager: Optional run manager for callbacks and tracing
+
+        Returns:
+            The string generated by the model
+        """
+
+        pass

dhti_elixir_base/mcp.py

@@ -0,0 +1,15 @@
+from mcp.server.fastmcp import FastMCP
+
+
+class BaseMCPServer(FastMCP):
+    """Base class for MCP servers, extending FastMCP for custom functionality."""
+
+    def __init__(self, name: str | None = None):
+        self._name = name or "BaseMCPServer"
+        super().__init__(name=self._name)
+
+    @property
+    def name(self):
+        """Return the name of this MCP server instance."""
+        return self._name
+

dhti_elixir_base/model.py

@@ -0,0 +1,47 @@
+import sys
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+from time import perf_counter
+
+
+# Set up logger
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+log = logging.getLogger(__name__)
+
+
+class BaseModel(ABC):
+    """A model class to lead the model and tokenizer"""
+
+    model: Any = None
+
+    def __init__(
+        self,
+        model: Any,
+    ) -> None:
+        self.model = model
+
+    @classmethod
+    @abstractmethod
+    def load(cls) -> None:
+        if cls.model is None:
+            log.info("Loading model")
+            t0 = perf_counter()
+            # Load the model here
+            elapsed = 1000 * (perf_counter() - t0)
+            log.info("Model warm-up time: %d ms.", elapsed)
+        else:
+            log.info("Model is already loaded")
+
+    @classmethod
+    @abstractmethod
+    def predict(cls, input: Any, **kwargs) -> Any:
+        assert input is not None and cls.model is not None  # Sanity check
+
+        # Make sure the model is loaded.
+        cls.load()
+        t0 = perf_counter()
+        # Predict here
+        elapsed = 1000 * (perf_counter() - t0)
+        log.info("Model prediction time: %d ms.", elapsed)
+        return None

dhti_elixir_base/mydi.py

@@ -0,0 +1,16 @@
+from kink import di
+
+
+def get_di(mydi: str, default=None):
+    try:
+        _module = mydi.split("_", 1)[0]
+        _mydi = mydi.split("_", 1)[1]
+    except IndexError:
+        return di[mydi]
+    try:
+        return di[_module + "_" + _mydi]
+    except KeyError:
+        try:
+            return di[_mydi]
+        except KeyError:
+            return default

dhti_elixir_base/server.py

@@ -0,0 +1,56 @@
+import logging
+import re
+import sys
+from abc import ABC
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from . import BaseModel
+
+# Set up logger
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+log = logging.getLogger(__name__)
+
+
+class BaseServer(ABC):
+    """A server class to load the model and tokenizer"""
+
+    class RequestSchema(BaseModel):
+        text: str = Field()
+        labels: list = Field()
+        required: list = Field()
+
+    class ResponseSchema(BaseModel):
+        text: str = Field()
+
+    request_schema = RequestSchema
+    response_schema = ResponseSchema
+
+    def __init__(
+        self, model: BaseModel, request_schema: Any = None, response_schema: Any = None
+    ) -> None:
+        self.model = model
+        if request_schema is not None:
+            self.request_schema = request_schema
+        if response_schema is not None:
+            self.response_schema = response_schema
+
+    @property
+    def name(self):
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.__class__.__name__).lower()
+
+    def health_check(self) -> Any:
+        """Health check endpoint"""
+        self.model.load()
+        return {"status": "ok"}
+
+    def get_schema(self) -> Any:
+        """Get the request schema"""
+        return self.request_schema
+
+    def predict(self, input: Any, **kwargs) -> Any:
+        _input = self.request_schema(**input)  # type: ignore
+        _result = self.model.predict(_input, **kwargs)
+        result = self.response_schema(**_result)  # type: ignore
+        return result

dhti_elixir_base/space.py

@@ -0,0 +1,36 @@
+from agency.agent import Agent, action
+
+from . import BaseAgent
+
+
+class BaseSpace(Agent):
+
+    from typing import Optional
+
+    def __init__(self, agent: Optional[BaseAgent] = None, *args, **kwargs):
+        if agent:
+            self.agent = agent.get_agent()
+            super().__init__(id=agent.name, *args, **kwargs)
+
+    @action
+    def say(self, content: str, current_patient_context: str = ""):
+        """Search for a patient in the FHIR database."""
+        #! TODO: Needs bootstrapping here.
+
+        message = {
+            "input": content,
+            "current_patient_context": current_patient_context,
+        }
+        response_content = self.agent.invoke(message)
+        self.send(
+            {
+                "to": self.current_message()["from"], # type: ignore
+                "action": {
+                    "name": "say",
+                    "args": {
+                        "content": response_content["output"],
+                    },
+                },
+            }
+        )
+        return True

dhti_elixir_base-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: dhti-elixir-base
+Version: 0.1.0
+Summary: DHTI Elixir Base
+Project-URL: Documentation, https://github.com/dermatologist/dhti
+Project-URL: Homepage, https://nuchange.ca
+Project-URL: Repository, https://github.com/dermatologist/dhti-elixir-base
+Author-email: Bell Eapen <github_public@gulfdoctor.net>
+License-Expression: MPL-2.0
+License-File: AUTHORS.md
+License-File: LICENSE
+Keywords: Gen AI,dhti,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0,>=3.10
+Requires-Dist: agency
+Requires-Dist: fhiry
+Requires-Dist: httpx
+Requires-Dist: kink
+Requires-Dist: langchain-community
+Requires-Dist: langchain-core
+Requires-Dist: langchain-mcp-adapters
+Requires-Dist: langgraph
+Requires-Dist: mcp
+Requires-Dist: overrides
+Requires-Dist: pytest
+Requires-Dist: python-dotenv
+Provides-Extra: testing
+Requires-Dist: pytest; extra == 'testing'
+Requires-Dist: pytest-cov; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# dhti-elixir-base
+
+* [DHTI](https://github.com/dermatologist/dhti) Elixir Template
+* WIP
+
+## Using the template
+* Use the template to create a new repository on GitHub with the default branch set to develop
+* Clone the repository to your local machine
+* rename `elixir-template` to your elixir-packagename
+* rename `elixir_template` to your elixir_packagename
+* rename the directory `dhti_elixir_base` to your dhti_elixir_packagename
+
+## Installation
+* poetry install
+* poetry install dhti-elixir-packagename --extras docs
+
+## Environment Setup
+
+Override [`dhti_elixir_base/bootstrap.py`](dhti_elixir_base/bootstrap.py) with your own configuration.
+
+## Usage
+
+To use this package, you should first have the LangChain CLI installed:
+
+```shell
+pip install -U langchain-cli
+```
+
+If you want to add this to an existing project, you can just run:
+
+```shell
+langchain app add --repo https://github.com/dermatologist/dhti-elixir-base --branch develop
+```
+
+And add the following code to your `server.py` file:
+```python
+from dhti_elixir_base.bootstrap import bootstrap
+bootstrap()
+from dhti_elixir_base.chain import chain as dhti_elixir_base_chain
+
+add_routes(app, dhti_elixir_base_chain, path="/dhti-elixir-base")
+```
+
+If you are inside this directory, then you can spin up a LangServe instance directly by:
+
+```shell
+langchain serve
+```
+
+This will start the FastAPI app with a server is running locally at
+[http://localhost:8000](http://localhost:8000)
+
+We can see all templates at [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)
+We can access the playground at [http://127.0.0.1:8000/dhti-elixir-base/playground](http://127.0.0.1:8000/dhti-elixir-base/playground)
+
+We can access the template from code with:
+
+```python
+from langserve.client import RemoteRunnable
+
+runnable = RemoteRunnable("http://localhost:8000/dhti-elixir-base")
+```

dhti_elixir_base-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+dhti_elixir_base/__init__.py,sha256=pVXd9FJLbqlqr3bEbiXoVOoQd9NAu-ZWEl3Gc4IyvHo,825
+dhti_elixir_base/agent.py,sha256=71lyRCidYLEEInFzjxXIP4Qpqq-LDjEDvin-F-IoVgM,7377
+dhti_elixir_base/chain.py,sha256=llMpJcGnDAVH6gPzUV3IsOSboE5gGlqOX3mnbkC4rjY,5145
+dhti_elixir_base/graph.py,sha256=XLCzsDhXW7FC3QlkuJjSyvfOWykjO81eiKfbgagdWAo,6171
+dhti_elixir_base/llm.py,sha256=HwTrXwsjOJTNNLNUw6uukhjqYfvgYsmREdVqPRBW55A,2366
+dhti_elixir_base/mcp.py,sha256=vRzYHLa9ULL1TbTWqGB05O3GwCSFnyChozxn0TbLakc,411
+dhti_elixir_base/model.py,sha256=HCWw755iAgHd1bOZ9BtpX2u574Vc1pmK4PZHDVgZUk8,1198
+dhti_elixir_base/mydi.py,sha256=bJBWmW94ynra_dp8aApOA-gKFmyjHcbZ7iWdrZFHtsI,358
+dhti_elixir_base/server.py,sha256=AjRYe2e8e4SzGJjMIxAcbOgNNkoCzf2-o8C_e5yVvPQ,1539
+dhti_elixir_base/space.py,sha256=3BKB-5N9IVZNsPmoaqythxDPr9zui0F6ntmCqn8u_K0,1026
+dhti_elixir_base-0.1.0.dist-info/METADATA,sha256=QzZ9RvGL57YPQxM0PIv7KYV4Ad3GX4oY0CJG6bxpnbQ,3420
+dhti_elixir_base-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dhti_elixir_base-0.1.0.dist-info/licenses/AUTHORS.md,sha256=cTqmVu4I7k4HyaZkdJgV2LQVppFPlRDC_w9iQi40P_I,86
+dhti_elixir_base-0.1.0.dist-info/licenses/LICENSE,sha256=09btKnCai4LASlVvyTZUp9T0DVNyTY_awOppr_cIfB4,15922
+dhti_elixir_base-0.1.0.dist-info/RECORD,,

dhti_elixir_base-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dhti_elixir_base-0.1.0.dist-info/licenses/AUTHORS.md

@@ -0,0 +1,3 @@
+# Contributors
+
+* dermatologist [github@gulfdoctor.net](mailto:github@gulfdoctor.net)

dhti_elixir_base-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,362 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+     means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the terms of
+        a Secondary License.
+
+1.6. "Executable Form"
+
+     means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+     means a work that combines Covered Software with other material, in a
+     separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+     means this document.
+
+1.9. "Licensable"
+
+     means having the right to grant, to the maximum extent possible, whether
+     at the time of the initial grant or subsequently, any and all of the
+     rights conveyed by this License.
+
+1.10. "Modifications"
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+      means any patent claim(s), including without limitation, method,
+      process, and apparatus claims, in any patent Licensable by such
+      Contributor that would be infringed, but for the grant of the License,
+      by the making, using, selling, offering for sale, having made, import,
+      or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+      means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, "You" includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, "control" means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or
+        as part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its
+        Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution
+     become effective for each Contribution on the date the Contributor first
+     distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under
+     this License. No additional rights or licenses will be implied from the
+     distribution or licensing of Covered Software under this License.
+     Notwithstanding Section 2.1(b) above, no patent license is granted by a
+     Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party's
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of
+        its Contributions.
+
+     This License does not grant any rights in the trademarks, service marks,
+     or logos of any Contributor (except as may be necessary to comply with
+     the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this
+     License (see Section 10.2) or under the terms of a Secondary License (if
+     permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its
+     Contributions are its original creation(s) or it has sufficient rights to
+     grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under
+     applicable copyright doctrines of fair use, fair dealing, or other
+     equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under
+     the terms of this License. You must inform recipients that the Source
+     Code Form of the Covered Software is governed by the terms of this
+     License, and how they can obtain a copy of this License. You may not
+     attempt to alter or restrict the recipients' rights in the Source Code
+     Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this
+        License, or sublicense it under different terms, provided that the
+        license for the Executable Form does not attempt to limit or alter the
+        recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for
+     the Covered Software. If the Larger Work is a combination of Covered
+     Software with a work governed by one or more Secondary Licenses, and the
+     Covered Software is not Incompatible With Secondary Licenses, this
+     License permits You to additionally distribute such Covered Software
+     under the terms of such Secondary License(s), so that the recipient of
+     the Larger Work may, at their option, further distribute the Covered
+     Software under the terms of either this License or such Secondary
+     License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices
+     (including copyright notices, patent notices, disclaimers of warranty, or
+     limitations of liability) contained within the Source Code Form of the
+     Covered Software, except that You may alter any license notices to the
+     extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on
+     behalf of any Contributor. You must make it absolutely clear that any
+     such warranty, support, indemnity, or liability obligation is offered by
+     You alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute,
+   judicial order, or regulation then You must: (a) comply with the terms of
+   this License to the maximum extent possible; and (b) describe the
+   limitations and the code they affect. Such description must be placed in a
+   text file included with all distributions of the Covered Software under
+   this License. Except to the extent prohibited by statute or regulation,
+   such description must be sufficiently detailed for a recipient of ordinary
+   skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing
+     basis, if such Contributor fails to notify You of the non-compliance by
+     some reasonable means prior to 60 days after You have come back into
+     compliance. Moreover, Your grants from a particular Contributor are
+     reinstated on an ongoing basis if such Contributor notifies You of the
+     non-compliance by some reasonable means, this is the first time You have
+     received notice of non-compliance with this License from such
+     Contributor, and You become compliant prior to 30 days after Your receipt
+     of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions,
+     counter-claims, and cross-claims) alleging that a Contributor Version
+     directly or indirectly infringes any patent, then the rights granted to
+     You by any and all Contributors for the Covered Software under Section
+     2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an "as is" basis,
+   without warranty of any kind, either expressed, implied, or statutory,
+   including, without limitation, warranties that the Covered Software is free
+   of defects, merchantable, fit for a particular purpose or non-infringing.
+   The entire risk as to the quality and performance of the Covered Software
+   is with You. Should any Covered Software prove defective in any respect,
+   You (not any Contributor) assume the cost of any necessary servicing,
+   repair, or correction. This disclaimer of warranty constitutes an essential
+   part of this License. No use of  any Covered Software is authorized under
+   this License except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from
+   such party's negligence to the extent applicable law prohibits such
+   limitation. Some jurisdictions do not allow the exclusion or limitation of
+   incidental or consequential damages, so this exclusion and limitation may
+   not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts
+   of a jurisdiction where the defendant maintains its principal place of
+   business and such litigation shall be governed by laws of that
+   jurisdiction, without reference to its conflict-of-law provisions. Nothing
+   in this Section shall prevent a party's ability to bring cross-claims or
+   counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject
+   matter hereof. If any provision of this License is held to be
+   unenforceable, such provision shall be reformed only to the extent
+   necessary to make it enforceable. Any law or regulation which provides that
+   the language of a contract shall be construed against the drafter shall not
+   be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version
+      of the License under which You originally received the Covered Software,
+      or under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a
+      modified version of this License if you rename the license and remove
+      any references to the name of the license steward (except to note that
+      such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+      Licenses If You choose to distribute Source Code Form that is
+      Incompatible With Secondary Licenses under the terms of this version of
+      the License, the notice described in Exhibit B of this License must be
+      attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+      This Source Code Form is "Incompatible
+      With Secondary Licenses", as defined by
+      the Mozilla Public License, v. 2.0.