Descarga de llm client sdk - Descarga de código fuente llm client sdk

llm client sdk

Otro código fuente

0.8.0

Descargar

LLM-Cliente-SDK

LLM-Client-SDK es un SDK para una integración perfecta con modelos de lenguaje grande de IA generativa (actualmente admitimos modelos OpenAI, Google, AI21, HuggingfaceHub, Aleph Alpha, Anthropic, Local con transformadores y muchos más pronto).

Nuestra visión es proporcionar un SDK asíncrono nativo y listo para producción mientras creamos una integración poderosa y rápida con diferentes LLM sin permitir que el usuario pierda flexibilidad (parámetros API, puntos finales, etc.). *También proporcionamos la versión de sincronización; consulte más detalles a continuación en la sección Uso.

Interfaz básica

El paquete expone dos interfaces simples para una integración perfecta con LLM (en el futuro, ampliaremos la interfaz para admitir más tareas como modelos de listas, ediciones, etc.):

 de abc import ABC, método abstracto de clases de datos importar clase de datos, campo de escribir importar Cualquiera, Opcional de enum importar Enumde dataclasses_json importar dataclass_json, configde aiohttp importar ClientSessionclass BaseLLMClient(ABC):@abstractmethodasync def text_completion(self, rápido: str, **kwargs) -> lista [cadena]: generar NotImplementedError()async def get_tokens_count(self, text: str, **kwargs) -> int:raise NotImplementedError()class Role(Enum):SYSTEM = "system"USER = "user"ASSISTANT = "assistant"@dataclass_json@dataclassclass ChatMessage:role: Role = campo(metadatos=config(codificador=lambda rol: rol.valor, decodificador=Rol))contenido: strname: Opcional[cadena] = campo(predeterminado=Ninguno, metadatos=config(excluir=nombre lambda: el nombre es Ninguno))ejemplo: bool = campo(predeterminado=Falso, metadatos=config(excluir=lambda _: Verdadero))

    @dataclassclass LLMAPIClientConfig:api_key: strsession: ClientSessionbase_url: Opcional[str] = Nonedefault_model: Opcional[str] = Ningunoheaders: dict[str, Any] = campo(default_factory=dict)class BaseLLMAPIClient(BaseLLMClient, ABC):def __init__(self, configuración: LLMAPIClientConfig):
        ...@abstractmethodasync def text_completion(self, solicitud: str, modelo: Opcional[str] = Ninguno, max_tokens: int | Ninguno = Ninguno, temperatura: Opcional[float] = Ninguno, top_p: Opcional[float] = Ninguno, * *kwargs) -> lista[cadena]:raise NotImplementedError()async def chat_completion(self, mensajes: lista[ChatMessage], temperatura: float = 0, max_tokens: int = 16, modelo: Opcional[str] = Ninguno, **kwargs) -> list[str]:raise NotImplementedError()async def embedding(self, text: str, model: Opcional[ str] = Ninguno, **kwargs) -> lista[float]:raise NotImplementedError()async def get_chat_tokens_count(self, mensajes: lista[ChatMessage], **kwargs) -> int:raise NotImplementedError()

Requisitos

Pitón 3.9+

Instalación

Si le preocupa el tamaño del paquete, puede instalar sólo los clientes que necesita; de forma predeterminada, no instalamos ninguno de los clientes.

Para todos los clientes actuales soporte

 $ pip instalar llm-cliente[todos]

Solo para la interfaz base y algunos clientes LLM ligeros (AI21 y Aleph Alpha)

 $ pip instalar llm-cliente

Dependencias opcionales

Para soporte para todos los clientes API actuales

 $ pip instalar llm-cliente[api]

Solo para soporte al cliente local

 $ pip instalar llm-cliente[local]

Para soporte de sincronización

 $ pip instalar llm-client[sincronización]

Solo para soporte OpenAI

 $ pip instalar llm-cliente[openai]

Solo para soporte de HuggingFace

 $ pip instalar llm-client[huggingface]

Uso

Uso de OpenAI directamente a través de OpenAIClient: máximo control y mejores prácticas en producción

 importar osdesde aiohttp importar ClientSessiondesde llm_client importar ChatMessage, Role, OpenAIClient, LLMAPIClientConfigOPENAI_API_KEY = os.environ["API_KEY"]OPENAI_ORG_ID = os.getenv("ORG_ID")async def main():async with ClientSession() as session:llm_client = OpenAIClient(LLMAPIClientConfig(OPENAI_API_KEY, session, default_model="text-davinci-003", headers={"OpenAI-Organization": OPENAI_ORG_ID})) # Los encabezados son opcionalestext = "Esto es de hecho una prueba"messages = [ChatMessage(role) =Rol.USUARIO, content="¡Hola!"),ChatMessage(role=Role.SYSTEM, content="¡Hola! ¿Cómo puedo ayudarte hoy?")]print("número de tokens:", await llm_client.get_tokens_count(text)) # 5print("número de tokens para completar el chat:", await llm_client.get_chat_tokens_count(mensajes, model="gpt-3.5-turbo")) # 23print("chat generado:", await llm_client.chat_completion(messages, model="gpt-3.5-turbo")) # ['¡Hola! ¿En qué puedo ayudarle hoy?']print("texto generado:", await llm_client.text_completion(text)) # [' stringnnSí, esta es una cadena de prueba. Las cadenas de prueba se utilizan para']print("incrustación generada:", await llm_client.embedding(text)) # [0.0023064255, -0.009327292, ...]

Uso de LLMAPIClientFactory: perfecto si desea moverse rápido y no manejar la sesión del cliente usted mismo

 importar osdesde llm_client importar LLMAPIClientFactory, LLMAPIClientTypeOPENAI_API_KEY = os.environ["API_KEY"]async def main():async con LLMAPIClientFactory() como llm_api_client_factory:llm_client = llm_api_client_factory.get_llm_api_client(LLMAPIClientType.OPEN_AI, api_key=OPENAI_API_KEY, default_model="text-davinci-003")await llm_client.text_completion(prompt="Esto sí que es una prueba")await llm_client.text_completion(prompt="Esto sí que es una prueba ", tokens_max=50)
        # O si no desea utilizar asyncfrom llm_client import init_sync_llm_api_clientllm_client = init_sync_llm_api_client(LLMAPIClientType.OPEN_AI, api_key=OPENAI_API_KEY, default_model="text-davinci-003")llm_client.text_completion(prompt="Esto sí que es un test")llm_client.text_completion(prompt="Esto sí que es una prueba", max_tokens=50)

modelo local

 importar osfrom transformadores importar AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizerfrom llm_client importar LocalClientConfig, LocalClientasync def main():try:model = AutoModelForCausalLM.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])except ValueError:model = AutoModelForSeq2SeqLM.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])tokenizer = AutoTokenizer.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])llm_client = LocalClient(LocalClientConfig(model, tokenizer, os.environ["TENSORS_TYPE"], os.environ["DEVICE"]))await llm_client.text_completion(prompt="Esto es de hecho una prueba")await llm_client.text_completion(prompt="Esto de hecho es una prueba", max_tokens=50)# O si no No quiero usar asyncimport async_to_synctry:model = AutoModelForCausalLM.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])except ValueError:model = AutoModelForSeq2SeqLM.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])tokenizer = AutoTokenizer.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])llm_client = LocalClient(LocalClientConfig(model, tokenizer, os.environ["TENSORS_TYPE"], os.environ["DEVICE"]))llm_client = async_to_sync.methods(llm_client)llm_client.text_completion(prompt="Esto sí que es una prueba") llm_client.text_completion(prompt="Esto sí que es una prueba", tokens_max=50)