Download llm client sdk - download do código-fonte llm client sdk

llm client sdk

Outro código-fonte

0.8.0

Baixar

LLM-Cliente-SDK

LLM-Client-SDK é um SDK para integração perfeita com modelos de linguagem grande de IA generativa (atualmente oferecemos suporte - OpenAI, Google, AI21, HuggingfaceHub, Aleph Alpha, Anthropic, modelos locais com transformadores - e muitos mais em breve).

Nossa visão é fornecer SDK assíncrono, nativo e pronto para produção, ao mesmo tempo em que criamos uma integração poderosa e rápida com diferentes LLM, sem permitir que o usuário perca qualquer flexibilidade (parâmetros de API, endpoints, etc.). *Também fornecemos versão sincronizada, veja mais detalhes abaixo na seção Uso.

Interface Básica

O pacote expõe duas interfaces simples para integração perfeita com LLMs (no futuro, expandiremos a interface para suportar mais tarefas como modelos de lista, edições, etc.):

 de abc importar ABC, abstractmethodfrom dataclasses importar dataclass, fieldfrom digitar import Any, Opcionalfrom enum import Enumfrom dataclasses_json importar dataclass_json, configfrom aiohttp importar ClientSessionclass BaseLLMClient(ABC):@abstractmethodasync def text_completion(self, prompt: str, **kwargs) -> list [str]:raise NotImplementedError()async def get_tokens_count(self, text: str, **kwargs) -> int:raise NotImplementedError()class Role(Enum):SYSTEM = "system"USER = "user"ASSISTANT = "assistente"@dataclass_json@dataclassclass ChatMessage:role: Role = campo(metadados=config(encoder=lambda role: role.value, decoder=Role))content: strname: Opcional[str] = field(default=None, metadata=config(exclude=lambda name: name is None))exemplo: bool = field(default=False, metadata=config(exclude=lambda _: True))

    @dataclassclass LLMAPIClientConfig:api_key: strsession: ClientSessionbase_url: Opcional[str] = Nonedefault_model: Opcional[str] = Noneheaders: dict[str, Any] = field(default_factory=dict)class BaseLLMAPIClient(BaseLLMClient, ABC):def __init__(self, configuração: LLMAPIClientConfig):
        ...@abstractmethodasync def text_completion(self, prompt: str, modelo: Opcional[str] = Nenhum, max_tokens: int | Nenhum = Nenhum, temperatura: Opcional[float] = Nenhum, top_p: Opcional[float] = Nenhum, * *kwargs) -> list[str]:raise NotImplementedError()async def chat_completion(self, messages: list[ChatMessage], temperatura: float = 0, max_tokens: int = 16, modelo: Opcional[str] = Nenhum, **kwargs) -> lista[str]:raise NotImplementedError() async def embedding(self, texto: str, modelo: Opcional[str] = Nenhum, **kwargs) -> list[float]:raise NotImplementedError()async def get_chat_tokens_count(self, mensagens: list[ChatMessage], **kwargs) -> int:raise NotImplementedError()

Requisitos

Python 3.9+

Instalação

Se você está preocupado com o tamanho do pacote, você pode instalar apenas os clientes que precisa; por padrão, não instalamos nenhum dos clientes.

Para todos os clientes atuais, suporte

 $ pip instalar llm-client[todos]

Apenas para a interface base e alguns clientes LLMs leves (AI21 e Aleph Alpha)

 $ pip instalar llm-client

Dependências opcionais

Para todos os clientes de API atuais, suporte

 $ pip instalar llm-cliente[api]

Apenas para suporte ao cliente local

 $ pip install llm-client[local]

Para suporte de sincronização

 $ pip instalar llm-client[sincronização]

Apenas para suporte OpenAI

 $ pip instalar llm-cliente[openai]

Apenas para suporte HuggingFace

 $ pip install llm-client[huggingface]

Uso

Usando OpenAI diretamente através do OpenAIClient – Máximo controle e melhores práticas em produção

 importar osfrom aiohttp importar ClientSessionfrom llm_client importar ChatMessage, Role, OpenAIClient, LLMAPIClientConfigOPENAI_API_KEY = os.environ["API_KEY"]OPENAI_ORG_ID = os.getenv("ORG_ID")async def main():async com ClientSession() as session:llm_client = OpenAIClient(LLMAPIClientConfig(OPENAI_API_KEY, session, default_model="text-davinci-003", headers={"OpenAI-Organization": OPENAI_ORG_ID})) # Os cabeçalhos são opcionaistext = "Este é realmente um teste"messages = [ChatMessage(role =Função.USUÁRIO, content="Olá!"),ChatMessage(role=Role.SYSTEM, content="Olá! Como posso ajudá-lo hoje?")]print("número de tokens:", await llm_client.get_tokens_count(text)) # 5print("número de tokens para conclusão do chat:", await llm_client.get_chat_tokens_count(messages, model="gpt-3.5-turbo")) # 23print("chat gerado:", await llm_client.chat_completion(messages, model="gpt-3.5-turbo")) # ['Olá! Como posso ajudá-lo hoje?']print("generated text:", await llm_client.text_completion(text)) # [' stringnnSim, esta é uma string de teste. Strings de teste são usadas para']print("incorporação gerada:", await llm_client.embedding(text)) # [0.0023064255, -0.009327292, ...]

Usando LLMAPIClientFactory - Perfeito se você deseja avançar rapidamente e não lidar com a sessão do cliente sozinho

 importar osfrom llm_client importar LLMAPIClientFactory, LLMAPIClientTypeOPENAI_API_KEY = os.environ["API_KEY"]async def main():async com LLMAPIClientFactory() as 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="Este é realmente um teste")await llm_client.text_completion(prompt="Este é realmente um teste", max_tokens=50)
        # Ou se você não quiser usar 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="Este é realmente um test")llm_client.text_completion(prompt="Este é realmente um teste", 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="Este é realmente um teste")await llm_client.text_completion(prompt="Este é realmente um teste", max_tokens=50)# Ou se você não não quero usar asyncimport async_to_synctry:model = AutoModelForCausalLM.from_pretrained(os.environ["MODEL_NAME_OR_PATH"])exceto 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="Este é realmente um teste")llm_client .text_completion(prompt="Este é realmente um teste", max_tokens=50)