langroid 0.1.52__tar.gz → 0.1.54__tar.gz

{langroid-0.1.52 → langroid-0.1.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.52
+Version: 0.1.54
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -75,7 +75,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-[![PyPI version](https://badge.fury.io/py/langroid.svg)](https://badge.fury.io/py/langroid)
+[![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
 [![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
 [![Lint](https://github.com/langroid/langroid/actions/workflows/validate.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/validate.yml)
@@ -135,6 +135,7 @@ for ideas on what to contribute.
 <summary> <b>:fire: Updates/Releases</b></summary>
 
 - **Aug 2023:**
+  - **[Hierarchical computation](https://langroid.github.io/langroid/examples/agent-tree/)** example using Langroid agents and task orchestration.
   - **0.1.51:** Support for global state, see [test_global_state.py](tests/main/test_global_state.py).
   - **:whale: Langroid Docker image**, available, see instructions below.
   - [**RecipientTool**](langroid/agent/tools/recipient_tool.py) enables (+ enforces) LLM to 
@@ -328,6 +329,26 @@ GOOGLE_CSE_ID=your-cse-id
 ```
 </details>
 
+<details>
+<summary><b>Setup instructions for Microsoft Azure OpenAI(click to expand)</b></summary> 
+In the root of the repo, copy the `.azure_env_template` file to a new file `.azure_env`: 
+
+```bash
+cp .azure_env_template .azure_env
+```
+
+The file `.azure_env` contains four environment variables that are required to use Azure OpenAI: `AZURE_API_KEY`, `OPENAI_API_BASE`, `OPENAI_API_VERSION`, and `OPENAI_DEPLOYMENT_NAME`
+
+This page [Microsoft Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line&pivots=programming-language-python#environment-variables)
+provides more information, and you can set each environment variable as follows:
+
+- `AZURE_API_KEY`, from the value of `API_KEY`
+- `OPENAI_API_BASE` from the value of `ENDPOINT`, typically looks like `https://your.domain.azure.com`.
+- For `OPENAI_API_VERSION`, you can use the default value in `.azure_env_template`, and latest version can be found [here](https://learn.microsoft.com/en-us/azure/ai-services/openai/whats-new#azure-openai-chat-completion-general-availability-ga)
+- `OPENAI_DEPLOYMENT_NAME` is the deployment name you chose when you deployed the GPT-35-Turbo or GPT-4 models.
+
+</details>
+
 ---
 
 # :whale: Docker Instructions

{langroid-0.1.52 → langroid-0.1.54}/README.md

@@ -5,7 +5,7 @@
 
 <div align="center">
 
-[![PyPI version](https://badge.fury.io/py/langroid.svg)](https://badge.fury.io/py/langroid)
+[![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
 [![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
 [![Lint](https://github.com/langroid/langroid/actions/workflows/validate.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/validate.yml)
@@ -65,6 +65,7 @@ for ideas on what to contribute.
 <summary> <b>:fire: Updates/Releases</b></summary>
 
 - **Aug 2023:**
+  - **[Hierarchical computation](https://langroid.github.io/langroid/examples/agent-tree/)** example using Langroid agents and task orchestration.
   - **0.1.51:** Support for global state, see [test_global_state.py](tests/main/test_global_state.py).
   - **:whale: Langroid Docker image**, available, see instructions below.
   - [**RecipientTool**](langroid/agent/tools/recipient_tool.py) enables (+ enforces) LLM to 
@@ -258,6 +259,26 @@ GOOGLE_CSE_ID=your-cse-id
 ```
 </details>
 
+<details>
+<summary><b>Setup instructions for Microsoft Azure OpenAI(click to expand)</b></summary> 
+In the root of the repo, copy the `.azure_env_template` file to a new file `.azure_env`: 
+
+```bash
+cp .azure_env_template .azure_env
+```
+
+The file `.azure_env` contains four environment variables that are required to use Azure OpenAI: `AZURE_API_KEY`, `OPENAI_API_BASE`, `OPENAI_API_VERSION`, and `OPENAI_DEPLOYMENT_NAME`
+
+This page [Microsoft Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line&pivots=programming-language-python#environment-variables)
+provides more information, and you can set each environment variable as follows:
+
+- `AZURE_API_KEY`, from the value of `API_KEY`
+- `OPENAI_API_BASE` from the value of `ENDPOINT`, typically looks like `https://your.domain.azure.com`.
+- For `OPENAI_API_VERSION`, you can use the default value in `.azure_env_template`, and latest version can be found [here](https://learn.microsoft.com/en-us/azure/ai-services/openai/whats-new#azure-openai-chat-completion-general-availability-ga)
+- `OPENAI_DEPLOYMENT_NAME` is the deployment name you chose when you deployed the GPT-35-Turbo or GPT-4 models.
+
+</details>
+
 ---
 
 # :whale: Docker Instructions

{langroid-0.1.52 → langroid-0.1.54}/langroid/agent/base.py

@@ -1,9 +1,20 @@
 import inspect
 import json
 import logging
+import textwrap
 from abc import ABC
 from contextlib import ExitStack
-from typing import Callable, Dict, List, Optional, Set, Tuple, Type, cast, no_type_check
+from typing import (
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    cast,
+    no_type_check,
+)
 
 from pydantic import BaseSettings, ValidationError
 from rich import print
@@ -15,6 +26,9 @@ from langroid.agent.tool_message import INSTRUCTION, ToolMessage
 from langroid.language_models.base import (
     LanguageModel,
     LLMConfig,
+    LLMMessage,
+    LLMResponse,
+    LLMTokenUsage,
 )
 from langroid.mytypes import DocMetaData, Entity
 from langroid.parsing.json import extract_top_level_json
@@ -60,6 +74,8 @@ class Agent(ABC):
         self.llm_tools_map: Dict[str, Type[ToolMessage]] = {}
         self.llm_tools_handled: Set[str] = set()
         self.llm_tools_usable: Set[str] = set()
+        self.total_llm_token_cost = 0.0
+        self.total_llm_token_usage = 0
         self.default_human_response: Optional[str] = None
         self._indent = ""
         self.llm = LanguageModel.create(config.llm)
@@ -315,7 +331,7 @@ class Agent(ABC):
         else:
             user_msg = Prompt.ask(
                 f"[blue]{self.indent}Human "
-                f"(respond or q, x to exit current level, "
+                "(respond or q, x to exit current level, "
                 f"or hit enter to continue)\n{self.indent}",
             ).strip()
 
@@ -410,6 +426,7 @@ class Agent(ABC):
             if self.llm.get_stream():
                 console.print(f"[green]{self.indent}", end="")
             response = self.llm.generate(prompt, output_len)
+
         displayed = False
         if not self.llm.get_stream() or response.cached:
             # we would have already displayed the msg "live" ONLY if
@@ -417,7 +434,7 @@ class Agent(ABC):
             console.print(f"[green]{self.indent}", end="")
             print("[green]" + response.message)
             displayed = True
-
+        self.update_token_usage(response, prompt, self.llm.get_stream())
         return ChatDocument.from_LLMResponse(response, displayed)
 
     def get_tool_messages(self, msg: str | ChatDocument) -> List[ToolMessage]:
@@ -594,10 +611,66 @@ class Agent(ABC):
             result = f"Error in tool/function-call {tool_name} usage: {type(e)}: {e}"
         return result  # type: ignore
 
-    def num_tokens(self, prompt: str) -> int:
+    def num_tokens(self, prompt: str | List[LLMMessage]) -> int:
         if self.parser is None:
             raise ValueError("Parser must be set, to count tokens")
-        return self.parser.num_tokens(prompt)
+        if isinstance(prompt, str):
+            return self.parser.num_tokens(prompt)
+        else:
+            return sum([self.parser.num_tokens(m.content) for m in prompt])
+
+    def update_token_usage(
+        self, response: LLMResponse, prompt: str | List[LLMMessage], stream: bool
+    ) -> None:
+        """
+        Updates `response.usage` obj (token usage and cost fields).the usage memebr
+        It updates the cost after checking the cache and updates the
+        tokens (prompts and completion) if the response stream is True, because OpenAI
+        doesn't returns these fields.
+
+        Args:
+            response (LLMResponse): LLMResponse object
+            prompt (str | List[LLMMessage]): prompt or list of LLMMessage objects
+            stream (bool): whether to update the usage in the response object
+                if the response is not cached.
+        """
+        if response is not None:
+            # Note: If response was not streamed, then
+            # `response.usage` would already have been set by the API,
+            # so we only need to update in the stream case.
+            if stream:
+                # usage, cost = 0 when response is from cache
+                prompt_tokens = 0
+                completion_tokens = 0
+                cost = 0.0
+                if not response.cached:
+                    prompt_tokens = self.num_tokens(prompt)
+                    completion_tokens = self.num_tokens(response.message)
+                    cost = self.compute_token_cost(prompt_tokens, completion_tokens)
+                response.usage = LLMTokenUsage(
+                    prompt_tokens=prompt_tokens,
+                    completion_tokens=completion_tokens,
+                    cost=cost,
+                )
+
+            if settings.debug and response.usage is not None:
+                print(
+                    textwrap.dedent(
+                        f"""
+                        Stream: {stream}
+                        prompt_tokens: {response.usage.prompt_tokens}
+                        completion_tokens: {response.usage.completion_tokens}
+                        """.lstrip()
+                    )
+                )
+            # update total counters
+            if response.usage is not None:
+                self.total_llm_token_cost += response.usage.cost
+                self.total_llm_token_usage += response.usage.total_tokens
+
+    def compute_token_cost(self, prompt: int, completion: int) -> float:
+        price = cast(LanguageModel, self.llm).chat_cost()
+        return (price[0] * prompt + price[1] * completion) / 1000
 
     def ask_agent(
         self,

{langroid-0.1.52 → langroid-0.1.54}/langroid/agent/chat_agent.py

@@ -453,7 +453,8 @@ class ChatAgent(Agent):
             else:
                 response_str = response.message
             print(cached + "[green]" + response_str)
-
+        stream = self.llm.get_stream()  # type: ignore
+        self.update_token_usage(response, messages, stream)
         return ChatDocument.from_LLMResponse(response, displayed)
 
     def _llm_response_temp_context(self, message: str, prompt: str) -> ChatDocument:

{langroid-0.1.52 → langroid-0.1.54}/langroid/agent/chat_document.py

@@ -7,6 +7,7 @@ from langroid.language_models.base import (
     LLMFunctionCall,
     LLMMessage,
     LLMResponse,
+    LLMTokenUsage,
     Role,
 )
 from langroid.mytypes import DocMetaData, Document, Entity
@@ -29,7 +30,7 @@ class ChatDocMetaData(DocMetaData):
     block: None | Entity = None
     sender_name: str = ""
     recipient: str = ""
-    usage: int = 0
+    usage: Optional[LLMTokenUsage]
     cached: bool = False
     displayed: bool = False
 
@@ -119,7 +120,8 @@ class ChatDocument(Document):
 
     @staticmethod
     def from_LLMResponse(
-        response: LLMResponse, displayed: bool = False
+        response: LLMResponse,
+        displayed: bool = False,
     ) -> "ChatDocument":
         recipient, message = response.get_recipient_and_message()
         return ChatDocument(
@@ -183,7 +185,10 @@ class ChatDocument(Document):
             content = message
 
         return LLMMessage(
-            role=sender_role, content=content, function_call=fun_call, name=sender_name
+            role=sender_role,
+            content=content,
+            function_call=fun_call,
+            name=sender_name,
         )
 
 

{langroid-0.1.52 → langroid-0.1.54}/langroid/agent/special/doc_chat_agent.py

@@ -7,7 +7,7 @@ Functionality includes:
 """
 import logging
 from contextlib import ExitStack
-from typing import List, Optional, no_type_check
+from typing import List, Optional, Tuple, no_type_check
 
 from rich import print
 from rich.console import Console
@@ -304,7 +304,7 @@ class DocChatAgent(ChatAgent):
         )
 
     @no_type_check
-    def get_relevant_extracts(self, query: str) -> List[Document]:
+    def get_relevant_extracts(self, query: str) -> Tuple[str, List[Document]]:
         """
         Get list of docs or extracts relevant to a query. These could be:
         - the original docs, if they exist and are not too long, or
@@ -316,6 +316,7 @@ class DocChatAgent(ChatAgent):
             query (str): query to search for
 
         Returns:
+            query (str): stand-alone version of input query
             List[Document]: list of relevant docs
 
         """
@@ -341,20 +342,18 @@ class DocChatAgent(ChatAgent):
                     k=self.config.parsing.n_similar_docs,
                 )
             if len(docs_and_scores) == 0:
-                return []
+                return query, []
             passages = [
                 Document(content=d.content, metadata=d.metadata)
                 for (d, _) in docs_and_scores
             ]
 
-        # if passages not too long, no need to extract relevant verbatim text
-        extracts = passages
-        if self.doc_length(passages) > self.config.max_context_tokens:
-            with console.status("[cyan]LLM Extracting verbatim passages..."):
-                with StreamingIfAllowed(self.llm, False):
-                    extracts = self.llm.get_verbatim_extracts(query, passages)
+        with console.status("[cyan]LLM Extracting verbatim passages..."):
+            with StreamingIfAllowed(self.llm, False):
+                extracts = self.llm.get_verbatim_extracts(query, passages)
+                extracts = [e for e in extracts if e.content != NO_ANSWER]
 
-        return extracts
+        return query, extracts
 
     @no_type_check
     def answer_from_docs(self, query: str) -> Document:
@@ -373,7 +372,8 @@ class DocChatAgent(ChatAgent):
                 source="None",
             ),
         )
-        extracts = self.get_relevant_extracts(query)
+        # query may be updated to a stand-alone version
+        query, extracts = self.get_relevant_extracts(query)
         if len(extracts) == 0:
             return response
         with ExitStack() as stack:

{langroid-0.1.52 → langroid-0.1.54}/langroid/agent/task.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Callable, Dict, List, Optional, Type, cast
+from typing import Callable, Dict, List, Optional, Set, Type, cast
 
 from rich import print
 
@@ -155,7 +155,8 @@ class Task:
 
         # other sub_tasks this task can delegate to
         self.sub_tasks: List[Task] = []
-        self.parent_task: Optional[Task] = None
+        self.parent_task: Set[Task] = set()
+        self.caller: Task | None = None  # which task called this task's `run` method
 
     def __repr__(self) -> str:
         return f"{self.name}"
@@ -165,10 +166,9 @@ class Task:
 
     @property
     def _level(self) -> int:
-        if self.parent_task is None:
+        if self.caller is None:
             return 0
-        else:
-            return self.parent_task._level + 1
+        return self.caller._level + 1
 
     @property
     def _indent(self) -> str:
@@ -199,7 +199,7 @@ class Task:
             return
         assert isinstance(task, Task), f"added task must be a Task, not {type(task)}"
 
-        task.parent_task = self
+        task.parent_task.add(self)  # add myself to set of parent tasks of `task`
         self.sub_tasks.append(task)
         self.name_sub_task_map[task.name] = task
         self.responders.append(cast(Responder, task))
@@ -226,18 +226,18 @@ class Task:
             )
         else:
             self.pending_message = msg
-            if self.pending_message is not None and self.parent_task is not None:
-                # msg may have come from parent_task, so we pretend this is from
+            if self.pending_message is not None and self.caller is not None:
+                # msg may have come from `caller`, so we pretend this is from
                 # the CURRENT task's USER entity
                 self.pending_message.metadata.sender = Entity.USER
 
-        if self.parent_task is not None and self.parent_task.logger is not None:
-            self.logger = self.parent_task.logger
+        if self.caller is not None and self.caller.logger is not None:
+            self.logger = self.caller.logger
         else:
             self.logger = RichFileLogger(f"logs/{self.name}.log", color=self.color_log)
 
-        if self.parent_task is not None and self.parent_task.tsv_logger is not None:
-            self.tsv_logger = self.parent_task.tsv_logger
+        if self.caller is not None and self.caller.tsv_logger is not None:
+            self.tsv_logger = self.caller.tsv_logger
         else:
             self.tsv_logger = setup_file_logger("tsv_logger", f"logs/{self.name}.tsv")
             header = ChatDocLoggerFields().tsv_header()
@@ -250,6 +250,7 @@ class Task:
         self,
         msg: Optional[str | ChatDocument] = None,
         turns: int = -1,
+        caller: None | Task = None,
     ) -> Optional[ChatDocument]:
         """
         Loop over `step()` until task is considered done or `turns` is reached.
@@ -264,6 +265,7 @@ class Task:
                 LLM or Human (User).
             turns (int): number of turns to run the task for;
                 default is -1, which means run until task is done.
+            caller (Task|None): the calling task, if any
 
         Returns:
             Optional[ChatDocument]: valid response from the agent
@@ -281,7 +283,7 @@ class Task:
         ):
             # this task is not the intended recipient so return None
             return None
-
+        self.caller = caller
         self.init(msg)
         # sets indentation to be printed prior to any output from agent
         self.agent.indent = self._indent
@@ -447,20 +449,22 @@ class Task:
 
     def response(self, e: Responder, turns: int = -1) -> Optional[ChatDocument]:
         """
-        Get response to `self.pending_message` from an entity.
+        Get response to `self.pending_message` from a responder.
         If response is __valid__ (i.e. it ends the current turn of seeking
         responses):
             -then return the response as a ChatDocument object,
             -otherwise return None.
         Args:
-            e (Entity): entity to get response from
+            e (Responder): responder to get response from.
+            turns (int): number of turns to run the task for.
+                Default is -1, which means run until task is done.
         Returns:
             Optional[ChatDocument]: response to `self.pending_message` from entity if
             valid, None otherwise
         """
         if isinstance(e, Task):
             actual_turns = e.turns if e.turns > 0 else turns
-            return e.run(self.pending_message, turns=actual_turns)
+            return e.run(self.pending_message, turns=actual_turns, caller=self)
         else:
             return self._entity_responder_map[cast(Entity, e)](self.pending_message)
 
@@ -521,10 +525,10 @@ class Task:
             self.pending_message is None
             # LLM decided task is done
             or DONE in self.pending_message.content
-            or (  # current task is addressing message to parent task
-                self.parent_task is not None
-                and self.parent_task.name != ""
-                and self.pending_message.metadata.recipient == self.parent_task.name
+            or (  # current task is addressing message to caller task
+                self.caller is not None
+                and self.caller.name != ""
+                and self.pending_message.metadata.recipient == self.caller.name
             )
             or (
                 # Task controller is "stuck", has nothing to say

langroid-0.1.54/langroid/io/refs.md

@@ -0,0 +1 @@
+https://chat.openai.com/share/7c440b3f-ddbf-4ae6-a26f-ac28d947d403

langroid-0.1.54/langroid/language_models/azure_openai.py

@@ -0,0 +1,72 @@
+import os
+
+import openai
+from dotenv import load_dotenv
+
+from langroid.language_models.openai_gpt import OpenAIGPT, OpenAIGPTConfig
+
+
+class AzureConfig(OpenAIGPTConfig):
+    """
+    Configuration for Azure OpenAI GPT. You need to supply the env vars listed in
+    ``.azure_env_template`` after renaming the file to ``.azure_env``. Because this file
+    is used by this class to find the env vars.
+    Attributes:
+        type (str): should be ``azure``
+        api_version (str): can be set inside the ``.azure_env``
+        deployment_name (str): can be set inside the ``.azure_env`` and should be based
+        the custom name you chose for your deployment when you deployed a model
+    """
+
+    type: str = "azure"
+    api_version: str = "2023-07-01-preview"
+    deployment_name: str = ""
+
+
+class AzureGPT(OpenAIGPT):
+    """
+    Class to access OpenAI LLMs via Azure. These env variables can be obtained from the
+    file `.azure_env`. Azure OpenAI doesn't support ``completion``
+    Attributes:
+        config: AzureConfig object
+        api_key: Azure API key
+        api_base: Azure API base url
+        api_version: Azure API version
+    """
+
+    def __init__(self, config: AzureConfig):
+        super().__init__(config)
+        self.config: AzureConfig = config
+        self.api_type = config.type
+        openai.api_type = self.api_type
+        load_dotenv(dotenv_path=".azure_env")
+        self.api_key = os.getenv("AZURE_API_KEY", "")
+        if self.api_key == "":
+            raise ValueError(
+                """
+                AZURE_API_KEY not set in .env file,
+                please set it to your Azure API key."""
+            )
+
+        self.api_base = os.getenv("OPENAI_API_BASE", "")
+        if self.api_base == "":
+            raise ValueError(
+                """
+                OPENAI_API_BASE not set in .env file,
+                please set it to your Azure API key."""
+            )
+        # we don't need this for ``api_key`` because it's handled inside
+        # ``openai_gpt.py`` methods before invoking chat/completion calls
+        else:
+            openai.api_base = self.api_base
+
+        self.api_version = os.getenv("OPENAI_API_VERSION", "") or config.api_version
+        openai.api_version = self.api_version
+
+        self.deployment_name = os.getenv("OPENAI_DEPLOYMENT_NAME", "")
+        if self.deployment_name == "":
+            raise ValueError(
+                """
+                OPENAI_DEPLOYMENT_NAME not set in .env file,
+                please set it to your Azure API key."""
+            )

{langroid-0.1.52 → langroid-0.1.54}/langroid/language_models/base.py

@@ -36,6 +36,9 @@ class LLMConfig(BaseSettings):
     stream: bool = False  # stream output from API?
     cache_config: None | RedisCacheConfig | MomentoCacheConfig = None
 
+    # Dict of model -> (input/prompt cost, output/completion cost)
+    cost_per_1k_tokens: Optional[Dict[str, Tuple[float, float]]] = None
+
 
 class LLMFunctionCall(BaseModel):
     """
@@ -63,6 +66,16 @@ class LLMFunctionSpec(BaseModel):
     parameters: Dict[str, Any]
 
 
+class LLMTokenUsage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cost: float = 0.0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.prompt_tokens + self.completion_tokens
+
+
 class Role(str, Enum):
     USER = "user"
     SYSTEM = "system"
@@ -116,7 +129,7 @@ class LLMResponse(BaseModel):
 
     message: str
     function_call: Optional[LLMFunctionCall] = None
-    usage: int
+    usage: Optional[LLMTokenUsage]
     cached: bool = False
 
     def to_LLMMessage(self) -> LLMMessage:
@@ -193,13 +206,21 @@ class LanguageModel(ABC):
             config: configuration for language model
         Returns: instance of language model
         """
+        from langroid.language_models.azure_openai import AzureGPT
         from langroid.language_models.openai_gpt import OpenAIGPT
 
         if config is None or config.type is None:
             return None
+
+        openai: Union[Type[AzureGPT], Type[OpenAIGPT]]
+
+        if config.type == "azure":
+            openai = AzureGPT
+        else:
+            openai = OpenAIGPT
         cls = dict(
-            openai=OpenAIGPT,
-        ).get(config.type, OpenAIGPT)
+            openai=openai,
+        ).get(config.type, openai)
         return cls(config)  # type: ignore
 
     @abstractmethod
@@ -248,6 +269,13 @@ class LanguageModel(ABC):
             raise ValueError("No context length  specified")
         return self.config.context_length[self.config.completion_model]
 
+    def chat_cost(self) -> Tuple[float, float]:
+        if self.config.chat_model is None:
+            raise ValueError("No chat model specified")
+        if self.config.cost_per_1k_tokens is None:
+            raise ValueError("No cost per 1k tokens  specified")
+        return self.config.cost_per_1k_tokens[self.config.chat_model]
+
     def followup_to_standalone(
         self, chat_history: List[Tuple[str, str]], question: str
     ) -> str:
@@ -368,7 +396,10 @@ class LanguageModel(ABC):
             sources = ""
         return Document(
             content=content,
-            metadata={"source": "SOURCE: " + sources, "cached": llm_response.cached},
+            metadata={
+                "source": "SOURCE: " + sources,
+                "cached": llm_response.cached,
+            },
         )