agentUniverse 0.0.9.dev2__tar.gz → 0.0.10.dev1__tar.gz

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentUniverse
-Version: 0.0.9.dev2
+Version: 0.0.10.dev1
 Summary: agentUniverse is a framework for developing applications powered by multi-agent base on large language model.
 Home-page: https://github.com/alipay/agentUniverse
 Author: AntGroup
@@ -21,6 +21,7 @@ Requires-Dist: anthropic (>=0.26.0,<0.27.0)
 Requires-Dist: cffi (>=1.15.1,<2.0.0)
 Requires-Dist: chromadb (==0.4.24)
 Requires-Dist: dashscope (>=1.19.1,<2.0.0)
+Requires-Dist: duckduckgo-search (>=6.1.7,<7.0.0)
 Requires-Dist: flask (>=2.3.2,<3.0.0)
 Requires-Dist: flask_cors (==4.0.0)
 Requires-Dist: googleapis-common-protos (>=1.63.0,<2.0.0)
@@ -32,9 +33,12 @@ Requires-Dist: langchain-community (==0.0.38)
 Requires-Dist: langchain-core (==0.1.52)
 Requires-Dist: loguru (==0.7.2)
 Requires-Dist: myst-parser (>=2.0.0,<3.0.0)
+Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: ollama (>=0.2.1,<0.3.0)
 Requires-Dist: openai (==1.13.3)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.25.0,<2.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pyarrow (>=16.1.0,<17.0.0)
 Requires-Dist: pydantic (>=2.6.4,<3.0.0)
 Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "store-ext"
 Requires-Dist: qianfan (>=0.3.12,<0.4.0)
@@ -44,6 +48,7 @@ Requires-Dist: sphinx-rtd-theme (>=2.0.0,<3.0.0)
 Requires-Dist: tiktoken (==0.5.2)
 Requires-Dist: tqdm (>=4.66.3,<5.0.0)
 Requires-Dist: werkzeug (>=3.0.3,<4.0.0)
+Requires-Dist: wikipedia (>=1.4.0,<2.0.0)
 Project-URL: Repository, https://github.com/alipay/agentUniverse
 Description-Content-Type: text/markdown
 

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/action/knowledge/embedding/dashscope_embedding.py

@@ -8,6 +8,7 @@
 import aiohttp
 import requests
 from typing import List, Generator, Optional
+from pydantic import Field
 import json
 
 from agentuniverse.base.util.env_util import get_from_env
@@ -27,14 +28,9 @@ def batched(inputs: List,
 
 class DashscopeEmbedding(Embedding):
     """The Dashscope embedding class."""
-    dashscope_api_key: Optional[str] = None
-
-    def __init__(self, **kwargs):
-        """Initialize the dashscope embedding class, need dashscope api key."""
-        super().__init__(**kwargs)
-        self.dashscope_api_key = get_from_env("DASHSCOPE_API_KEY")
-        if not self.dashscope_api_key:
-            raise Exception("No DASHSCOPE_API_KEY in your environment.")
+    dashscope_api_key: Optional[str] = Field(
+        default_factory=lambda: get_from_env("DASHSCOPE_API_KEY")
+    )
 
 
     def get_embeddings(self, texts: List[str]) -> List[List[float]]:
@@ -69,7 +65,8 @@ class DashscopeEmbedding(Embedding):
             )
             resp_json = response.json()
             return resp_json
-
+        if not self.dashscope_api_key:
+            raise Exception("No DASHSCOPE_API_KEY in your environment.")
         result = []
         post_params = {
             "model": self.embedding_model_name,
@@ -128,7 +125,8 @@ class DashscopeEmbedding(Embedding):
                 ) as resp:
                     resp_json = await resp.json()
             return resp_json
-
+        if not self.dashscope_api_key:
+            raise Exception("No DASHSCOPE_API_KEY in your environment.")
         result = []
         post_params = {
             "model": self.embedding_model_name,

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/action/knowledge/knowledge.py

@@ -5,7 +5,10 @@
 # @Author  : wangchongshi
 # @Email   : wangchongshi.wcs@antgroup.com
 # @FileName: knowledge.py
-from typing import Optional, Dict, List, Any
+from typing import Optional, Dict, List
+
+from langchain_core.utils.json import parse_json_markdown
+from langchain.tools import Tool as LangchainTool
 
 from agentuniverse.agent.action.knowledge.reader.reader import Reader
 from agentuniverse.agent.action.knowledge.store.document import Document
@@ -77,3 +80,37 @@ class Knowledge(ComponentBase):
         if component_configer.ext_info:
             self.ext_info = component_configer.ext_info
         return self
+
+    def langchain_query(self, query: str) -> str:
+        """Query the knowledge using LangChain.
+
+        Query documents from the store and return the results.
+        """
+        parse_query = parse_json_markdown(query)
+        query = Query(**parse_query)
+        knowledge = self.store.query(query)
+        res = ['This is Query Result']
+        for doc in knowledge:
+            res.append(doc.text)
+        return "\n=========================================\n".join(res)
+
+    def as_langchain_tool(self) -> LangchainTool:
+        """Convert the Knowledge object to a LangChain tool.
+
+        Returns:
+            Any: the LangChain tool object
+        """
+        args_description = """
+        This is a knowledge base tool, which stores the content you may need. To use this tool, you need to give a json string with the following format:
+        ```json
+        {
+            "query_str": "<your query here>",
+            "top_k": <number of results to return>,
+        }
+        ```
+        """
+        return LangchainTool(
+            name=self.name,
+            description=self.description + args_description,
+            func=self.langchain_query,
+        )

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/action/knowledge/store/chroma_store.py

@@ -6,10 +6,11 @@
 # @Email   : wangchongshi.wcs@antgroup.com
 # @FileName: chroma_store.py
 from typing import List, Any, Optional
+from pydantic import SkipValidation
 
 import chromadb
 from chromadb import QueryResult
-from chromadb.api.models import Collection
+from chromadb.api.models.Collection import Collection
 
 from agentuniverse.agent.action.knowledge.store.document import Document
 from agentuniverse.agent.action.knowledge.store.query import Query
@@ -28,7 +29,7 @@ class ChromaStore(Store):
     """
 
     collection_name: Optional[str] = 'chroma_db'
-    collection: Collection = None
+    collection: SkipValidation[Collection] = None
     persist_path: Optional[str] = None
 
     def __init__(self, **kwargs):

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/agent.py

@@ -6,21 +6,26 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: agent.py
 """The definition of agent paradigm."""
+import json
 from abc import abstractmethod
 from datetime import datetime
 from typing import Optional
 
+from langchain_core.utils.json import parse_json_markdown
+
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
 from agentuniverse.agent.output_object import OutputObject
 from agentuniverse.agent.plan.planner.planner import Planner
 from agentuniverse.agent.plan.planner.planner_manager import PlannerManager
+from agentuniverse.base.annotation.trace import trace_agent
 from agentuniverse.base.component.component_base import ComponentBase
 from agentuniverse.base.component.component_enum import ComponentEnum
 from agentuniverse.base.config.application_configer.application_config_manager \
     import ApplicationConfigManager
 from agentuniverse.base.config.component_configer.configers.agent_configer \
     import AgentConfiger
+from agentuniverse.base.util.logging.logging_util import LOGGER
 from agentuniverse.llm.llm import LLM
 
 
@@ -66,6 +71,7 @@ class Agent(ComponentBase):
         """
         pass
 
+    @trace_agent
     def run(self, **kwargs) -> OutputObject:
         """Agent instance running entry.
 
@@ -156,3 +162,35 @@ class Agent(ComponentBase):
                                                        plan=plan, memory=memory, action=action)
         self.agent_model = agent_model
         return self
+
+    def langchain_run(self, input: str, callbacks=None, **kwargs):
+        """Run the agent model using LangChain."""
+        try:
+            parse_result = parse_json_markdown(input)
+        except Exception as e:
+            LOGGER.error(f"langchain run parse_json_markdown error,input(parse_result) error({str(e)})")
+            return "Error , Your Action Input is not a valid JSON string"
+        output_object = self.run(**parse_result, callbacks=callbacks, **kwargs)
+        result_dict = {}
+        for key in self.output_keys():
+            result_dict[key] = output_object.get_data(key)
+        return result_dict
+
+    def as_langchain_tool(self):
+        """Convert to LangChain tool."""
+        from langchain.agents.tools import Tool
+        format_dict = {}
+        for key in self.input_keys():
+            format_dict.setdefault(key, "input val")
+        format_str = json.dumps(format_dict)
+
+        args_description = f"""
+        to use this tool,your input must be a json string,must contain all keys of {self.input_keys()},
+        and the value of the key must be a json string,the format of the json string is as follows:
+        ```{format_str}```
+        """
+        return Tool(
+            name=self.agent_model.info.get("name"),
+            func=self.langchain_run,
+            description=self.agent_model.info.get("description") + args_description
+        )

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/default/executing_agent/executing_agent.py

@@ -8,8 +8,11 @@
 import copy
 from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED
 from typing import Optional, Any
+
+from agentuniverse.agent.action.tool.tool_manager import ToolManager
 from agentuniverse.agent.agent import Agent
 from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.plan.planner.planner import Planner
 from agentuniverse.agent.plan.planner.planner_manager import PlannerManager
 
 
@@ -75,9 +78,35 @@ class ExecutingAgent(Agent):
         for task in framework:
             agent_input_copy: dict = copy.deepcopy(agent_input)
             agent_input_copy['input'] = task
+            planner: Planner = PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name'))
             futures.append(
-                self.executor.submit(
-                    PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name')).invoke,
-                    self.agent_model, agent_input_copy, input_object))
+                self.executor.submit(planner.invoke, self.agent_model, agent_input_copy,
+                                     self.process_intput_object(input_object, task, planner.input_key)))
         wait(futures, return_when=ALL_COMPLETED)
         return {'futures': futures}
+
+    def process_intput_object(self, input_object: InputObject, subtask: str, planner_input_key: str) -> InputObject:
+        """Process input object for the executing agent.
+
+        Args:
+            input_object (InputObject): input parameters passed by the user.
+            subtask (str): subtask to be executed.
+            planner_input_key (str): planner input key.
+
+        Returns:
+            input_object (InputObject): processed input object.
+        """
+        # get agent toolsets.
+        action: dict = self.agent_model.action or dict()
+        tools: list = action.get('tool') or list()
+        input_object_copy: InputObject = copy.deepcopy(input_object)
+        # wrap input_object for agent knowledge.
+        input_object_copy.add_data(planner_input_key, subtask)
+        # wrap input_object for agent toolsets.
+        for tool_name in tools:
+            tool = ToolManager().get_instance_obj(tool_name)
+            if tool is None:
+                continue
+            # note: only insert the first key of tool input.
+            input_object_copy.add_data(tool.input_keys[0], subtask)
+        return input_object_copy

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/memory/langchain_instance.py

@@ -9,6 +9,7 @@ from typing import List, Optional, Dict, Any
 
 from langchain_core.messages import BaseMessage, get_buffer_string
 from langchain.memory import ConversationSummaryBufferMemory, ConversationTokenBufferMemory
+from langchain_core.output_parsers import StrOutputParser
 
 from agentuniverse.agent.memory.enum import ChatMessageEnum
 from agentuniverse.agent.memory.message import Message
@@ -115,9 +116,8 @@ class AuConversationSummaryBufferMemory(ConversationSummaryBufferMemory):
         )
         prompt_version = self.prompt_version if self.prompt_version else 'chat_memory.summarizer_cn'
         prompt: Prompt = PromptManager().get_instance_obj(prompt_version)
-        chain = prompt.as_langchain() | self.llm
-        res = chain.invoke(input={'summary': existing_summary, 'new_lines': new_lines})
-        return res.content
+        chain = prompt.as_langchain() | self.llm | StrOutputParser()
+        return chain.invoke(input={'summary': existing_summary, 'new_lines': new_lines})
 
 
 class AuConversationTokenBufferMemory(ConversationTokenBufferMemory):

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/plan/planner/peer_planner/peer_planner.py

@@ -146,7 +146,7 @@ class PeerPlanner(Planner):
 
             if not expressing_result or jump_step in ["planning", "executing", "expressing"]:
                 if not expressingAgent:
-                    LOGGER.warn("no expression agent.")
+                    LOGGER.warn("no expressing agent.")
                     expressing_result = OutputObject({})
                 else:
                     LOGGER.info(f"Starting expressing agent.")
@@ -160,7 +160,7 @@ class PeerPlanner(Planner):
 
             if not reviewing_result or jump_step in ["planning", "executing", "expressing", "reviewing"]:
                 if not reviewingAgent:
-                    LOGGER.warn("no expression agent.")
+                    LOGGER.warn("no reviewing agent.")
                     loopResults.append({
                         "planning_result": planning_result,
                         "executing_result": executing_result,

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/agent/plan/planner/react_planner/react_planner.py

@@ -11,8 +11,12 @@ from langchain.agents import AgentExecutor, create_react_agent
 from langchain.tools import Tool as LangchainTool
 from langchain_core.runnables import RunnableConfig
 
+from agentuniverse.agent.action.knowledge.knowledge import Knowledge
+from agentuniverse.agent.action.knowledge.knowledge_manager import KnowledgeManager
 from agentuniverse.agent.action.tool.tool import Tool
 from agentuniverse.agent.action.tool.tool_manager import ToolManager
+from agentuniverse.agent.agent import Agent
+from agentuniverse.agent.agent_manager import AgentManager
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
 from agentuniverse.agent.memory.chat_memory import ChatMemory
@@ -78,6 +82,15 @@ class ReActPlanner(Planner):
         for tool_name in tool_names:
             tool: Tool = ToolManager().get_instance_obj(tool_name)
             lc_tools.append(tool.as_langchain())
+        knowledge: list = action.get('knowledge') or list()
+        for knowledge_name in knowledge:
+            knowledge_tool: Knowledge = KnowledgeManager().get_instance_obj(knowledge_name)
+            lc_tools.append(knowledge_tool.as_langchain_tool())
+
+        agents: list = action.get('agent') or list()
+        for agent_name in agents:
+            agent_tool: Agent = AgentManager().get_instance_obj(agent_name)
+            lc_tools.append(agent_tool.as_langchain_tool())
         return lc_tools
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:

agentuniverse-0.0.10.dev1/agentuniverse/base/annotation/trace.py

@@ -0,0 +1,160 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2024/6/5 15:33
+# @Author  : wangchongshi
+# @Email   : wangchongshi.wcs@antgroup.com
+# @FileName: trace.py
+import asyncio
+import functools
+import inspect
+import json
+
+from functools import wraps
+
+from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.output_object import OutputObject
+from agentuniverse.base.util.monitor.monitor import Monitor
+from agentuniverse.llm.llm_output import LLMOutput
+
+
+def trace_llm(func):
+    """Annotation: @trace_llm
+
+    Decorator to trace the LLM invocation, add llm input and output to the monitor.
+    """
+
+    @wraps(func)
+    async def wrapper_async(*args, **kwargs):
+        # get llm input from arguments
+        llm_input = _get_llm_input(func, *args, **kwargs)
+        # check whether the tracing switch is enabled
+        self = llm_input.pop('self', None)
+        if self and hasattr(self, 'tracing'):
+            if self.tracing is False:
+                return await func(*args, **kwargs)
+        # invoke function
+        result = await func(*args, **kwargs)
+        # not streaming
+        if isinstance(result, LLMOutput):
+            # add llm invocation info to monitor
+            Monitor().trace_llm_invocation(source=func.__qualname__, llm_input=llm_input, llm_output=result.text)
+            return result
+        else:
+            # streaming
+            async def gen_iterator():
+                llm_output = []
+                async for chunk in result:
+                    llm_output.append(chunk.text)
+                    yield chunk
+                # add llm invocation info to monitor
+                Monitor().trace_llm_invocation(source=func.__qualname__, llm_input=llm_input,
+                                               llm_output="".join(llm_output))
+
+            return gen_iterator()
+
+    @functools.wraps(func)
+    def wrapper_sync(*args, **kwargs):
+        # get llm input from arguments
+        llm_input = _get_llm_input(func, *args, **kwargs)
+        # check whether the tracing switch is enabled
+        self = llm_input.pop('self', None)
+        if self and hasattr(self, 'tracing'):
+            if self.tracing is False:
+                return func(*args, **kwargs)
+        # invoke function
+        result = func(*args, **kwargs)
+        # not streaming
+        if isinstance(result, LLMOutput):
+            # add llm invocation info to monitor
+            Monitor().trace_llm_invocation(source=func.__qualname__, llm_input=llm_input, llm_output=result.text)
+            return result
+        else:
+            # streaming
+            def gen_iterator():
+                llm_output = []
+                for chunk in result:
+                    llm_output.append(chunk.text)
+                    yield chunk
+                # add llm invocation info to monitor
+                Monitor().trace_llm_invocation(source=func.__qualname__, llm_input=llm_input,
+                                               llm_output="".join(llm_output))
+
+            return gen_iterator()
+
+    if asyncio.iscoroutinefunction(func):
+        # async function
+        return wrapper_async
+    else:
+        # sync function
+        return wrapper_sync
+
+
+def _get_llm_input(func, *args, **kwargs) -> dict:
+    """Get the llm input from arguments."""
+    sig = inspect.signature(func)
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+    return {k: v for k, v in bound_args.arguments.items()}
+
+
+def trace_agent(func):
+    """Annotation: @trace_agent
+
+    Decorator to trace the agent invocation, add agent input and output to the monitor.
+    """
+
+    @functools.wraps(func)
+    def wrapper_sync(*args, **kwargs):
+        # get agent input from arguments
+        agent_input = _get_agent_input(func, *args, **kwargs)
+        # check whether the tracing switch is enabled
+        source = func.__qualname__
+        self = agent_input.pop('self', None)
+
+        tracing = None
+        if isinstance(self, object):
+            agent_model = getattr(self, 'agent_model', None)
+            if isinstance(agent_model, object):
+                info = getattr(agent_model, 'info', None)
+                profile = getattr(agent_model, 'profile', None)
+                if isinstance(info, dict):
+                    source = info.get('name', None)
+                if isinstance(profile, dict):
+                    tracing = profile.get('tracing', None)
+
+        if tracing is False:
+            return func(*args, **kwargs)
+
+        # invoke function
+        result = func(*args, **kwargs)
+        # serialize agent input and output dict
+        agent_input = serialize_agent_invocation(agent_input)
+        agent_output = serialize_agent_invocation(result)
+        # add agent invocation info to monitor
+        Monitor().trace_agent_invocation(source=source, agent_input=agent_input, agent_output=agent_output)
+        return result
+
+    # sync function
+    return wrapper_sync
+
+
+def _get_agent_input(func, *args, **kwargs) -> dict:
+    """Get the agent input from arguments."""
+    sig = inspect.signature(func)
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+    return {k: v for k, v in bound_args.arguments.items()}
+
+
+def default_serializer(obj):
+    if isinstance(obj, InputObject):
+        return obj.to_dict()
+    elif isinstance(obj, OutputObject):
+        return obj.to_dict()
+    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+
+def serialize_agent_invocation(agent_invocation):
+    agent_invocation_serialized = json.loads(json.dumps(agent_invocation, default=default_serializer))
+    return agent_invocation_serialized

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/base/util/monitor/monitor.py

@@ -16,6 +16,7 @@ from agentuniverse.base.annotation.singleton import singleton
 from agentuniverse.base.config.configer import Configer
 
 LLM_INVOCATION_SUBDIR = "llm_invocation"
+AGENT_INVOCATION_SUBDIR = "agent_invocation"
 
 
 @singleton
@@ -54,11 +55,38 @@ class Monitor(BaseModel):
 
             # write to jsonl
             with jsonlines.open(path_save, 'a') as writer:
-                json_record = json.dumps(llm_invocation, ensure_ascii=False)
-                writer.write(json_record)
+                writer.write(llm_invocation)
 
     def _get_or_create_subdir(self, subdir: str) -> str:
         """Get or create a subdirectory if it doesn't exist in the monitor directory."""
         path = os.path.join(self.dir, subdir)
         os.makedirs(path, exist_ok=True)
         return path
+
+    def trace_agent_invocation(self, source: str, agent_input: Union[str, dict],
+                               agent_output: Union[str, dict]) -> None:
+        """Trace the agent invocation and save it to the monitor jsonl file."""
+        if self.activate:
+            try:
+                import jsonlines
+            except ImportError:
+                raise ImportError(
+                    "jsonlines is required to trace llm invocation: `pip install jsonlines`"
+                )
+            # get the current time
+            date = datetime.datetime.now()
+            agent_invocation = {
+                "source": source,
+                "date": date.strftime("%Y-%m-%d %H:%M:%S"),
+                "agent_input": agent_input,
+                "agent_output": agent_output,
+            }
+            # files are stored in hours
+            filename = f"agent_{source}_{date.strftime('%Y-%m-%d-%H')}.jsonl"
+            # file path to save
+            path_save = os.path.join(str(self._get_or_create_subdir(AGENT_INVOCATION_SUBDIR)), filename)
+
+            # write to jsonl
+            with jsonlines.open(path_save, 'a') as writer:
+                writer.write(agent_invocation)
+

agentuniverse-0.0.10.dev1/agentuniverse/llm/default/deep_seek_openai_style_llm.py

@@ -0,0 +1,70 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2024/5/21 17:49
+# @Author  : weizjajj 
+# @Email   : weizhongjie.wzj@antgroup.com
+# @FileName: claude_llm.py
+
+from typing import Optional, Any, Union, Iterator, AsyncIterator
+
+from pydantic import Field
+
+from agentuniverse.base.annotation.trace import trace_llm
+from agentuniverse.base.util.env_util import get_from_env
+from agentuniverse.llm.llm_output import LLMOutput
+from agentuniverse.llm.openai_style_llm import OpenAIStyleLLM
+
+DEEpSEEkMAXCONTETNLENGTH = {
+    "deepseek-chat": 32000,
+    "deepseek-coder": 32000,
+    "claude-3-haiku-20240307": 200000,
+    "claude-2.1": 200000,
+    "claude-2.0": 100000,
+    "claude-instant-1.2": 100000
+}
+
+
+class DefaultDeepSeekLLM(OpenAIStyleLLM):
+    """The agentUniverse default openai llm module.
+
+    LLM parameters, such as name/description/model_name/max_tokens,
+    are injected into this class by the default_openai_llm.yaml configuration.
+    """
+
+    api_key: Optional[str] = Field(default_factory=lambda: get_from_env("DEEPSEEK_API_KEY"))
+    organization: Optional[str] = Field(default_factory=lambda: get_from_env("DEEPSEEK_ORGANIZATION"))
+    api_base: Optional[str] = Field(default_factory=lambda: get_from_env("DEEPSEEK_API_BASE"))
+    proxy: Optional[str] = Field(default_factory=lambda: get_from_env("DEEPSEEK_PROXY"))
+
+    @trace_llm
+    def call(self, messages: list, **kwargs: Any) -> Union[LLMOutput, Iterator[LLMOutput]]:
+        """ The call method of the LLM.
+
+        Users can customize how the model interacts by overriding call method of the LLM class.
+
+        Args:
+            messages (list): The messages to send to the LLM.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        return super().call(messages, **kwargs)
+
+    @trace_llm
+    async def acall(self, messages: list, **kwargs: Any) -> Union[LLMOutput, AsyncIterator[LLMOutput]]:
+        """ The async call method of the LLM.
+
+        Users can customize how the model interacts by overriding acall method of the LLM class.
+
+        Args:
+            messages (list): The messages to send to the LLM.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        return await super().acall(messages, **kwargs)
+
+    def max_context_length(self) -> int:
+        """Max context length.
+
+          The total length of input tokens and generated tokens is limited by the openai model's context length.
+          """
+        return DEEpSEEkMAXCONTETNLENGTH.get(self.model_name, 4096)
+

agentuniverse-0.0.10.dev1/agentuniverse/llm/default/deep_seek_openai_style_llm.yaml

@@ -0,0 +1,8 @@
+name: 'default_deepseek_llm'
+description: 'default default_deepseek_llm llm with spi'
+model_name: 'deepseek-chat'
+max_tokens: 1000
+metadata:
+  type: 'LLM'
+  module: 'agentuniverse.llm.default.deep_seek_openai_style_llm'
+  class: 'DefaultDeepSeekLLM'

{agentuniverse-0.0.9.dev2 → agentuniverse-0.0.10.dev1}/agentuniverse/llm/llm.py

@@ -103,6 +103,8 @@ class LLM(ComponentBase):
         if component_configer.ext_info:
             self.ext_info = component_configer.ext_info
         self.tracing = component_configer.tracing
+        if 'max_context_length' in component_configer.configer.value:
+            self._max_context_length = component_configer.configer.value['max_context_length']
         return self
 
     def set_by_agent_model(self, **kwargs) -> None: