Bases: BasePrompt
, Generic[BaseCallResponseT, BaseCallResponseChunkT, BaseToolT]
, ABC
The base class abstract interface for calling LLMs.
Source code in mirascope/base/calls.py
| class BaseCall(
BasePrompt,
Generic[BaseCallResponseT, BaseCallResponseChunkT, BaseToolT],
ABC,
):
"""The base class abstract interface for calling LLMs."""
api_key: ClassVar[Optional[str]] = None
base_url: ClassVar[Optional[str]] = None
call_params: ClassVar[BaseCallParams] = BaseCallParams[BaseToolT](
model="gpt-3.5-turbo-0125"
)
@abstractmethod
def call(
self, retries: Union[int, Retrying] = 1, **kwargs: Any
) -> BaseCallResponseT:
"""A call to an LLM.
An implementation of this function must return a response that extends
`BaseCallResponse`. This ensures a consistent API and convenience across e.g.
different model providers.
"""
... # pragma: no cover
@abstractmethod
async def call_async(
self, retries: Union[int, AsyncRetrying] = 1, **kwargs: Any
) -> BaseCallResponseT:
"""An asynchronous call to an LLM.
An implementation of this function must return a response that extends
`BaseCallResponse`. This ensures a consistent API and convenience across e.g.
different model providers.
"""
... # pragma: no cover
@abstractmethod
def stream(
self, retries: Union[int, Retrying] = 1, **kwargs: Any
) -> Generator[BaseCallResponseChunkT, None, None]:
"""A call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
`BaseCallResponseChunk`. This ensures a consistent API and convenience across
e.g. different model providers.
"""
... # pragma: no cover
@abstractmethod
async def stream_async(
self, retries: Union[int, AsyncRetrying] = 1, **kwargs: Any
) -> AsyncGenerator[BaseCallResponseChunkT, None]:
"""A asynchronous call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
`BaseCallResponseChunk`. This ensures a consistent API and convenience across
e.g. different model providers."""
yield ... # type: ignore # pragma: no cover
############################## PRIVATE METHODS ###################################
def _setup(
self,
kwargs: dict[str, Any],
base_tool_type: Optional[Type[BaseToolT]] = None,
) -> tuple[dict[str, Any], Optional[list[Type[BaseToolT]]]]:
"""Returns the call params kwargs and tool types.
The tools in the call params first get converted into BaseToolT types. We then
need both the converted tools for the response (so it can construct actual tool
instances if present in the response) as well as the actual schemas injected
through kwargs. This function handles that setup.
"""
call_params = self.call_params.model_copy(update=kwargs)
kwargs = call_params.kwargs(tool_type=base_tool_type)
tool_types = None
if "tools" in kwargs and base_tool_type is not None:
tool_types = kwargs.pop("tools")
kwargs["tools"] = [tool_type.tool_schema() for tool_type in tool_types]
return kwargs, tool_types
|
call(retries=1, **kwargs)
abstractmethod
A call to an LLM.
An implementation of this function must return a response that extends
BaseCallResponse
. This ensures a consistent API and convenience across e.g.
different model providers.
Source code in mirascope/base/calls.py
| @abstractmethod
def call(
self, retries: Union[int, Retrying] = 1, **kwargs: Any
) -> BaseCallResponseT:
"""A call to an LLM.
An implementation of this function must return a response that extends
`BaseCallResponse`. This ensures a consistent API and convenience across e.g.
different model providers.
"""
... # pragma: no cover
|
call_async(retries=1, **kwargs)
abstractmethod
async
An asynchronous call to an LLM.
An implementation of this function must return a response that extends
BaseCallResponse
. This ensures a consistent API and convenience across e.g.
different model providers.
Source code in mirascope/base/calls.py
| @abstractmethod
async def call_async(
self, retries: Union[int, AsyncRetrying] = 1, **kwargs: Any
) -> BaseCallResponseT:
"""An asynchronous call to an LLM.
An implementation of this function must return a response that extends
`BaseCallResponse`. This ensures a consistent API and convenience across e.g.
different model providers.
"""
... # pragma: no cover
|
stream(retries=1, **kwargs)
abstractmethod
A call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
BaseCallResponseChunk
. This ensures a consistent API and convenience across
e.g. different model providers.
Source code in mirascope/base/calls.py
| @abstractmethod
def stream(
self, retries: Union[int, Retrying] = 1, **kwargs: Any
) -> Generator[BaseCallResponseChunkT, None, None]:
"""A call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
`BaseCallResponseChunk`. This ensures a consistent API and convenience across
e.g. different model providers.
"""
... # pragma: no cover
|
stream_async(retries=1, **kwargs)
abstractmethod
async
A asynchronous call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
BaseCallResponseChunk
. This ensures a consistent API and convenience across
e.g. different model providers.
Source code in mirascope/base/calls.py
| @abstractmethod
async def stream_async(
self, retries: Union[int, AsyncRetrying] = 1, **kwargs: Any
) -> AsyncGenerator[BaseCallResponseChunkT, None]:
"""A asynchronous call to an LLM that streams the response in chunks.
An implementation of this function must yield response chunks that extend
`BaseCallResponseChunk`. This ensures a consistent API and convenience across
e.g. different model providers."""
yield ... # type: ignore # pragma: no cover
|