lionagi 0.0.114__py3-none-any.whl → 0.0.116__py3-none-any.whl

lionagi/__init__.py

@@ -17,13 +17,16 @@ Copyright 2023 HaiyangLi <ocean@lionagi.ai>
 import logging
 from .version import __version__
 
+
 from .utils import *
 from .schema import *
-from .structure import *
-from .core import *
+from .structures import *
+from .loaders import *
+from .messages import *
 from .objs import *
-# from .datastore import *
-# from .structure import *
+from .tools import *
+from .core import *
+
 
 
 logger = logging.getLogger(__name__)

lionagi/bridge/__init__.py

@@ -1,7 +1,22 @@
-from .langchain import from_langchain
-from .llama_index import from_llama_index
+from .langchain import(
+    from_langchain, to_langchain_document, langchain_loader, 
+    langchain_loader, langchain_text_splitter
+)
+
+from .llama_index import (
+    from_llama_index, to_llama_index_textnode, get_llama_reader, 
+    llama_index_reader, get_llama_parser, llama_index_node_parser
+)
 
 __all__ = [
-    "from_langchain",
-    "from_llama_index"
+    'from_langchain',
+    'to_langchain_document',
+    'langchain_loader',
+    'from_llama_index',
+    'to_llama_index_textnode',
+    'get_llama_reader',
+    'llama_index_reader',
+    'get_llama_parser',
+    'llama_index_node_parser',
+    'langchain_text_splitter'
 ]

lionagi/bridge/langchain.py

@@ -1,7 +1,8 @@
-from typing import Union, Callable, List, Dict, Any
-from ..schema.base_schema import T, DataNode
-from ..utils.sys_util import change_dict_key
+from typing import Union, Callable, List, Dict, Any, TypeVar
+from lionagi.schema.data_node import DataNode
+from lionagi.utils.sys_util import change_dict_key
 
+T = TypeVar('T', bound='DataNode')
 
 def from_langchain(lc_doc: Any) -> T:
     """
@@ -79,6 +80,25 @@ def langchain_text_splitter(data: Union[str, List],
                             splitter_args: List[Any] = [], 
                             splitter_kwargs: Dict[str, Any] = {}) -> List[str]:
 
+    """
+    Splits text or a list of documents using a specified langchain text splitter.
+
+    Parameters:
+        data (Union[str, List]): The input text or list of documents to be split.
+
+        splitter (Union[str, Callable]): The name of the text splitter function or the function itself.
+
+        splitter_args (List[Any]): Positional arguments to pass to the splitter function.
+
+        splitter_kwargs (Dict[str, Any]): Keyword arguments to pass to the splitter function.
+
+    Returns:
+        List[str]: A list of chunks obtained by splitting the input.
+
+    Raises:
+        ValueError: If the specified text splitter is invalid or if the splitting fails.
+    """
+
     import langchain.text_splitter as text_splitter
 
     try:

lionagi/bridge/llama_index.py

@@ -1,7 +1,8 @@
-from typing import Union, Callable, List, Any, Dict
-from ..schema.base_schema import DataNode, T
-from ..utils.sys_util import change_dict_key
+from typing import Union, Callable, List, Any, Dict, TypeVar
+from lionagi.schema.data_node import DataNode
+from lionagi.utils.sys_util import change_dict_key
 
+T = TypeVar('T', bound='DataNode')
 
 def from_llama_index(llama_node: Any, **kwargs: Any) -> T:
     """
@@ -36,6 +37,7 @@ def to_llama_index_textnode(datanode: T, **kwargs: Any) -> Any:
     dnode = datanode.to_dict()
     change_dict_key(dnode, old_key='content', new_key='text')
     change_dict_key(dnode, old_key='node_id', new_key='id_')
+    dnode['text'] = str(dnode['text'])
     
     dnode = {**dnode, **kwargs}
     return TextNode.from_dict(dnode)

lionagi/configs/__init__.py

@@ -1,5 +1,5 @@
 from .oai_configs import oai_schema
-from .openrouter_config import openrouter_schema
+from .openrouter_configs import openrouter_schema
 
 __all__ = [
     "oai_schema",

lionagi/configs/oai_configs.py

@@ -1,3 +1,6 @@
+# Default configs for the OpenAI API
+
+# ChatCompletion
 oai_chat_llmconfig = {
     "model": "gpt-4-1106-preview",
     "frequency_penalty": 0,
@@ -22,6 +25,8 @@ oai_chat_schema = {
     "config": oai_chat_llmconfig
     }
 
+
+# Finetune
 oai_finetune_llmconfig = {
     "model": "gpt-3.5-turbo",
     "hyperparameters": {
@@ -41,9 +46,91 @@ oai_finetune_schema = {
 }
 
 
+
+# Embeddings
+
+
+
+
+
+
+
+
+
+
+# Audio ---- create  speech
+
+oai_audio_speech_llmconfig = {
+    "model": "tts-1",
+    "voice": "alloy",
+    "response_format": "mp3",
+    "speed": 1
+    }
+oai_audio_speech_schema = {
+    "required" : ["model", "voice"],
+    "optional": ["response_format", "speed"],
+    "input": "input",
+    "config": oai_audio_speech_llmconfig
+    }
+
+
+# Audio ----------- create transcription
+oai_audio_transcriptions_llmconfig = {
+    "model": "whisper-1",
+    "language": None,
+    "prompt": None,
+    "response_format": "json",
+    "temperature": 0
+    }
+oai_audio_transcriptions_schema = {
+    "required" : ["model", "voice"],
+    "optional": ["response_format", "language", "prompt", "response_format", "temperature"],
+    "input": "file",
+    "config": oai_audio_transcriptions_llmconfig
+    }
+
+
+# Audio ------------    translations
+oai_audio_translations_llmconfig = {
+    "model": "whisper-1",
+    "prompt": None,
+    "response_format": "json",
+    "temperature": 0
+    }
+
+oai_audio_translations_schema = {
+    "required" : ["model"],
+    "optional": ["response_format", "speed", "prompt", "temperature"],
+    "input": "file",
+    "config": oai_audio_translations_llmconfig
+    }
+
+
+
+
+
+
+
+
+# images
+
+
+
+
+
+
+
+
+
+
+
+
 oai_schema = {
     
     "chat": oai_chat_schema,
-    "finetune": oai_finetune_schema
+    "finetune": oai_finetune_schema,
+    "audio_speech": oai_audio_speech_schema, 
+    "audio_transcriptions": oai_audio_transcriptions_schema,
+    "audio_translations": oai_audio_translations_schema,
     
 }

lionagi/core/__init__.py

@@ -1,15 +1,12 @@
-# from .messages import Response, Instruction, System
+# from .instruction_set import InstructionSet
 from .conversations import Conversation
 from .sessions import Session
+from .flows import run_session      #, Flow
 
-# from .instruction_sets import InstructionSet
-# from .flows.flow import Flow
 
-
-__all__ = [
-    # "Response",
-    # "Instruction",
-    # "System",
+__all__  = [
     "Conversation",
-    "Session",              #"Flow", "InstructionSet"
+    "Session",
+    "run_session",
+    # "Flow"
 ]

lionagi/core/conversations/__init__.py

@@ -0,0 +1,5 @@
+from .conversation import Conversation
+
+__all__ = [
+    "Conversation"
+]

lionagi/core/conversations/conversation.py

@@ -0,0 +1,107 @@
+from typing import List, Any
+
+from lionagi.schema.base_node import BaseNode
+from lionagi.messages import Message, Response
+from lionagi.objs.messenger import Messenger
+
+
+class Conversation(BaseNode):
+    """
+    A conversation that handles messages and responses.
+
+    Attributes:
+        response_counts (int): A counter for the number of responses in the conversation.
+        messages (List[Message]): A list of message objects in the conversation.
+        msgr (Messenger): An instance of Messenger to create message objects.
+        responses (List[Response]): A list of response objects in the conversation.
+    """    
+
+    response_counts : int = 0
+    messages: List[Message] = []
+    msgr : Any = Messenger()
+    responses: List[Response] = []
+
+    def initiate_conversation(
+        self, system=None, instruction=None, 
+        context=None, name=None
+    ):
+        """
+        Initiates a new conversation, erase previous messages and responses.
+
+        Parameters:
+            system (Any, optional): System information to include in the initial message. Defaults to None.
+            instruction (Any, optional): Instruction details to include in the conversation. Defaults to None.
+            context (Any, optional): Contextual information relevant to the conversation. Defaults to None.
+            name (str, optional): The name associated with the conversation. Defaults to None.
+
+        Returns:
+            None
+        """
+        self.messages, self.responses = [], []
+        self.add_messages(system=system)
+        self.add_messages(instruction=instruction, context=context, name=name)
+
+    # modify the message adding to accomodate tools
+    def add_messages(
+        self, system=None, instruction=None, 
+        context=None, response=None, name=None
+    ):
+        """
+        Adds a new message object to the conversation messages list based on the provided parameters.
+
+        Parameters:
+            system (Any, optional): System information to include in the message. Defaults to None.
+            instruction (Any, optional): Instruction details to include in the message. Defaults to None.
+            context (Any, optional): Contextual information relevant to the message. Defaults to None.
+            response (Any, optional): Response details to include in the message. Defaults to None.
+            name (str, optional): The name associated with the message. Defaults to None.
+
+        Returns:
+            None
+        """
+        msg = self.msgr.create_message(
+            system=system, instruction=instruction, 
+            context=context, response=response, name=name
+        )
+        self.messages.append(msg)
+
+    def change_system(self, system):
+        """
+        Changes the system information of the first message in the conversation.
+
+        Parameters:
+            system (Any): The new system information to be set.
+
+        Returns:
+            None
+        """
+        self.messages[0] = self.msgr.create_message(system=system)
+
+
+    def keep_last_n_exchanges(self, n: int):
+        """
+        Keeps only the last n exchanges in the conversation, where an exchange starts with a user message. This function trims the conversation to retain only the specified number of the most recent exchanges. 
+        An exchange is defined as a sequence of messages starting with a user message. 
+        The first message in the conversation, typically a system message, is always retained.
+
+        Parameters:
+            n (int): The number of exchanges to keep in the conversation.
+
+        Returns:
+            None: The method modifies the conversation in place and does not return a value.
+
+        Raises:
+            ValueError: If n is not a positive integer.
+
+        Note:
+            This function assumes the first message in the conversation is a system message and each user message 
+            marks the beginning of a new exchange.
+        """
+        response_indices = [
+            index for index, message in enumerate(self.messages[1:]) 
+            if message.role == "user"
+        ]
+        if len(response_indices) >= n:
+            first_index_to_keep = response_indices[-n] + 1
+            self.messages = [self.system] + self.messages[first_index_to_keep:]
+            

lionagi/core/flows/__init__.py

@@ -0,0 +1,8 @@
+from .flow_util import run_session
+from .flow import Flow
+
+
+__all__ = [
+    "run_session",
+    "Flow"
+]

lionagi/core/flows/flow.py

@@ -0,0 +1,8 @@
+from lionagi.structures import Relationship, Structure
+from ..sessions import Session
+from .flow_util import run_session
+
+# represents structured sessions
+
+class Flow(Structure):
+    ...

lionagi/core/flows/flow_util.py

@@ -0,0 +1,62 @@
+from ..sessions import Session
+
+def get_config(temperature, max_tokens, key_scheme, n):
+    f = lambda i:{
+        "temperature": temperature[i], 
+        "max_tokens": max_tokens[i],
+    }
+    return {
+        "key": f"{key_scheme}{n+1}", 
+        "config": f(n)
+        }
+
+async def run_workflow(
+    session, prompts, temperature, max_tokens, 
+    key_scheme, num_prompts, context
+):
+    for i in range(num_prompts): 
+        key_, config_ = get_config(temperature, max_tokens, key_scheme, i)
+        if i == 0:
+            await session.initiate(instruction=prompts[key_], context=context, **config_)
+        else: 
+            await session.followup(instruction=prompts[key_], **config_)
+        
+        return session
+
+async def run_auto_workflow(
+    session, prompts, temperature, max_tokens, 
+    key_scheme, num_prompts, context
+):
+    for i in range(num_prompts): 
+        key_, config_ = get_config(temperature, max_tokens, key_scheme, i)
+        if i == 0:
+            await session.initiate(instruction=prompts[key_], context=context, **config_)
+        else: 
+            await session.auto_followup(instruction=prompts[key_], **config_)
+        
+        return session
+    
+async def run_session(
+    prompts, dir, llmconfig, key_scheme, num_prompts, 
+    temperature, max_tokens, type_=None, tools=None
+):
+    prompts_ = prompts.copy()
+    session = Session(
+        system=prompts_.pop('system', 'You are a helpful assistant'), 
+        dir = dir,
+        llmconfig = llmconfig
+    )
+    if tools:
+        session.register_tools(tools)
+    if type_ is None: 
+        session = await run_workflow(
+            session, prompts_, temperature, max_tokens, 
+            key_scheme=key_scheme, num_prompts=num_prompts
+            )
+    elif type_ == 'auto': 
+        session = await run_auto_workflow(
+            session, prompts_, temperature, max_tokens, 
+            key_scheme=key_scheme, num_prompts=num_prompts
+            )
+        
+    return session

lionagi/core/instruction_set/__init__.py

@@ -0,0 +1,5 @@
+from .instruction_sets import InstructionSet
+
+__all__ = [
+    "InstructionSet"   
+]

lionagi/core/instruction_set/instruction_sets.py

@@ -0,0 +1,7 @@
+from lionagi.structures import Relationship, Structure
+from ..messages import Message, Instruction
+
+# dynamically structured preconfigured instructions
+
+class InstructionSet(Structure):
+    ...

lionagi/core/sessions/__init__.py

@@ -0,0 +1,5 @@
+from .sessions import Session
+
+__all__ = [
+    "Session"
+]

lionagi/core/sessions/sessions.py

@@ -0,0 +1,187 @@
+import json
+from typing import Any
+from dotenv import load_dotenv
+
+from lionagi.schema import DataLogger, Tool
+from lionagi.utils import lcall, alcall
+from lionagi.services import OpenAIService
+from lionagi.endpoints import ChatCompletion
+from lionagi.objs.tool_manager import ToolManager
+from lionagi.configs.oai_configs import oai_schema
+from lionagi.core.conversations.conversation import Conversation
+
+load_dotenv()
+OAIService = OpenAIService()
+
+
+class Session:
+
+    def __init__(
+        self, system, dir=None, llmconfig=oai_schema['chat']['config'], 
+        service=OAIService
+    ):
+        self.conversation = Conversation()
+        self.system = system
+        self.llmconfig = llmconfig
+        self.logger_ = DataLogger(dir=dir)
+        self.service = service
+        self.tool_manager = ToolManager()
+    
+    def set_dir(self, dir):
+        self.logger_.dir = dir
+    
+    def set_system(self, system):
+        self.conversation.change_system(system)
+    
+    def set_llmconfig(self, llmconfig):
+        self.llmconfig = llmconfig
+    
+    def set_service(self, service):
+        self.service = service
+    
+    async def _output(self, invoke=True, out=True):
+        if invoke:
+            try: 
+                # func, args = self.tool_manager._get_function_call(self.conversation.responses[-1]['content'])
+                # outs = await self.tool_manager.invoke(func, args)
+                # self.conversation.add_messages(response=outs)
+
+                tool_uses = json.loads(self.conversation.responses[-1].message_content)
+                if 'function_list' in tool_uses.keys():
+                    func_calls = lcall(tool_uses['function_list'], self.tool_manager.get_function_call)
+                else:
+                    func_calls = lcall(tool_uses['tool_uses'], self.tool_manager.get_function_call)
+
+                outs = await alcall(func_calls, self.tool_manager.invoke)
+                for out, f in zip(outs, func_calls):
+                    response = {"function": f[0], "arguments": f[1], "output": out}
+                    self.conversation.add_messages(response=response)
+            except:
+                pass
+        if out:
+            return self.conversation.responses[-1].message_content
+    
+    def _is_invoked(self):
+        content = self.conversation.messages[-1].message_content
+        try:
+            if json.loads(content).keys() >= {'function', 'arguments', 'output'}:
+                return True
+        except: 
+            return False    
+
+    def register_tools(self, tools): #, update=False, new=False, prefix=None, postfix=None):
+        if not isinstance(tools, list):
+            tools=[tools]
+        self.tool_manager.register_tools(tools=tools) #, update=update, new=new, prefix=prefix, postfix=postfix)
+        # tools_schema = lcall(tools, lambda tool: tool.to_dict()['schema_'])
+        # if self.llmconfig['tools'] is None:
+        #     self.llmconfig['tools'] = tools_schema
+        # else:
+        #     self.llmconfig['tools'] += tools_schema
+
+    def _tool_parser(self, **kwargs):
+        # 1. single schema: dict
+        # 2. tool: Tool
+        # 3. name: str
+        # 4. list: 3 types of lists
+        def tool_check(tool):
+            if isinstance(tool, dict):
+                return tool
+            elif isinstance(tool, Tool):
+                return tool.schema_
+            elif isinstance(tool, str):
+                if self.tool_manager.name_existed(tool):
+                    tool = self.tool_manager.registry[tool]
+                    return tool.schema_
+                else:
+                    raise ValueError(f'Function {tool} is not registered.')
+
+        if 'tools' in kwargs:
+            if not isinstance(kwargs['tools'], list):
+                kwargs['tools']=[kwargs['tools']]
+            kwargs['tools'] = lcall(kwargs['tools'], tool_check)
+
+        else:
+            tool_kwarg = {"tools": self.tool_manager.to_tool_schema_list()}
+            kwargs = {**tool_kwarg, **kwargs}
+
+        return kwargs
+
+    async def initiate(self, instruction, system=None, context=None, 
+                       name=None, invoke=True, out=True, **kwargs) -> Any:
+        # if self.tool_manager.registry != {}:
+        #     if 'tools' not in kwargs:
+        #         tool_kwarg = {"tools": self.tool_manager.to_tool_schema_list()}
+        #         kwargs = {**tool_kwarg, **kwargs}
+        if self.tool_manager.registry != {}:
+            kwargs = self._tool_parser(**kwargs)
+        if self.service is not None:
+            await self.service._init()
+        config = {**self.llmconfig, **kwargs}
+        system = system or self.system
+        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context, name=name)
+        await self.call_chatcompletion(**config)
+        
+        return await self._output(invoke, out)
+
+    async def followup(self, instruction, system=None, context=None, 
+                       out=True, name=None, invoke=True, **kwargs) -> Any:
+        if system:
+            self.conversation.change_system(system)
+        self.conversation.add_messages(instruction=instruction, context=context, name=name)
+
+        if 'tool_parsed' in kwargs:
+            kwargs.pop('tool_parsed')
+        else:
+            if self.tool_manager.registry != {}:
+                kwargs = self._tool_parser(**kwargs)
+        # if self.tool_manager.registry != {}:
+        #     if 'tools' not in kwargs:
+        #         tool_kwarg = {"tools": self.tool_manager.to_tool_schema_list()}
+        #         kwargs = {**tool_kwarg, **kwargs}
+        config = {**self.llmconfig, **kwargs}
+        await self.call_chatcompletion(**config)
+
+        return await self._output(invoke, out)
+
+    async def auto_followup(self, instruct, num=3, **kwargs):
+        # if self.tool_manager.registry != {}:
+        #     if 'tools' not in kwargs:
+        #         tool_kwarg = {"tools": self.tool_manager.to_tool_schema_list()}
+        #         kwargs = {**tool_kwarg, **kwargs}
+        if self.tool_manager.registry != {}:
+            kwargs = self._tool_parser(**kwargs)
+
+        cont_ = True
+        while num > 0 and cont_ is True:
+            await self.followup(instruct, tool_choice="auto", tool_parsed=True, **kwargs)
+            num -= 1
+            cont_ = True if self._is_invoked() else False
+        if num == 0:
+            await self.followup(instruct, **kwargs, tool_parsed=True)
+
+    # def messages_to_csv(self, dir=None, filename="messages.csv", **kwargs):
+    #     dir = dir or self.logger_.dir
+    #     if dir is None:
+    #         raise ValueError("No directory specified.")
+    #     self.conversation.msg.to_csv(dir=dir, filename=filename, **kwargs)
+        
+    # def log_to_csv(self, dir=None, filename="llmlog.csv", **kwargs):
+    #     dir = dir or self.logger_.dir
+    #     if dir is None:
+    #         raise ValueError("No directory specified.")
+    #     self.logger_.to_csv(dir=dir, filename=filename, **kwargs)
+    
+    async def call_chatcompletion(self, schema=oai_schema['chat'], **kwargs):
+        messages = [message.message for message in self.conversation.messages]
+        payload = ChatCompletion.create_payload(messages=messages, schema=schema, llmconfig=self.llmconfig,**kwargs)
+        completion = await self.service.serve(payload=payload)
+        if "choices" in completion:
+            self.logger_({"input":payload, "output": completion})
+            self.conversation.add_messages(response=completion['choices'][0])
+            self.conversation.responses.append(self.conversation.messages[-1])
+            self.conversation.response_counts += 1
+            self.service.status_tracker.num_tasks_succeeded += 1
+        else:
+            self.service.status_tracker.num_tasks_failed += 1
+            

lionagi/endpoints/__init__.py

@@ -0,0 +1,5 @@
+from .chatcompletion import ChatCompletion
+
+__all__ = [
+    "ChatCompletion",
+]

lionagi/endpoints/audio.py

@@ -0,0 +1,17 @@
+# from .base_endpoint import BaseEndpoint
+
+
+# class Audio(BaseEndpoint):
+#     endpoint: str = "chat/completions"
+
+#     @classmethod
+#     def create_payload(scls, messages, llmconfig, schema, **kwargs):
+#         config = {**llmconfig, **kwargs}
+#         payload = {"messages": messages}
+#         for key in schema['required']:
+#             payload.update({key: config[key]})
+
+#         for key in schema['optional']:
+#             if bool(config[key]) is True and str(config[key]).lower() != "none":
+#                 payload.update({key: config[key]})
+#         return payload