langrila
useful tool to use API-based LLM in an easy way
Stars: 56
Langrila is a library that provides an easy way to use API-based LLM (Large Language Models) with an emphasis on simple architecture for readability. It supports various AI models for chat and embedding tasks, as well as retrieval functionalities using Qdrant, Chroma, and Usearch. Langrila also includes modules for function calling, conversation memory management, and prompt templates. It enforces coding policies for simplicity, responsibility independence, and minimum module implementation. The library requires Python version 3.10 to 3.13 and additional dependencies like OpenAI, Gemini, Qdrant, Chroma, and Usearch for specific functionalities.
README:
Langrila is an open-source third-party python package that is useful to use API-based LLM in the same interface. This package puts emphasis on simple architecture for readability. This package is just personal project.
- Sticking to simplicity : This library is motivated by simplifying architecture for readability. Thus too much abstraction should be avoided.
- Implementing minimum modules : The more functions each module has, the more complex the source code becomes. Langrila focuses on implementing minimum necessary functions in each module Basically module has only a responsibility expressed by thier module name and main function is implemented in a method easy to understand like
run()
orarun()
methods except for some.
- Topic branch are checkout from main branch.
- Topic branch should be small.
If necessary, set environment variables to use OpenAI API, Azure OpenAI Service, Gemini API, and Claude API; if using VertexAI or Amazon Bedrock, check each platform's user guide and authenticate in advance VertexAI and Amazon Bedrock.
- gpt-3.5-turbo-1106
- gpt-3.5-turbo-0125
- gpt-4-1106-preview
- gpt-4-vision-preview
- gpt-4-0125-preview
- gpt-4-turbo-2024-04-09
- gpt-4o-2024-05-13
- gpt-4o-mini-2024-07-18
- gpt-4o-2024-08-06
- chatgpt-4o-latest
- text-embedding-ada-002
- text-embedding-3-small
- text-embedding-3-large
{'gpt-4o-mini': 'gpt-4o-mini-2024-07-18',
'gpt-4o': 'gpt-4o-2024-08-06',
'gpt-4-turbo': 'gpt-4-turbo-2024-04-09',
'gpt-3.5-turbo': 'gpt-3.5-turbo-0125'}
- OpenAI
- Azure OpenAI
Basically all the models of gemini-1.5 family including experimental models.
- Google AI
- VertexAI
- claude-3.5-sonnet
- claude-3-opus
- claude-3-sonnet
- claude-3-haiku
- Anthropic
- Amazon Bedrock
- VertexAI (not tested)
v0.0.20 -> v0.1.0
Interface was updated in v0.1.0, and response format is different from before. Main difference is how to access response text in completion results.
Before:
response.message["content"]
In v0.1.0:
response.message.content[0].text # for single completion
For more details, please see introduction notebook.
v0.0.7 -> v0.0.8
Database modules has breaking changes from v0.0.7 to v0.0.8 such as rename of method, change the interface of some methods. For more details, see this PR.
v0.0.2 -> v0.0.3
I have integrated gemini api into langrila on v0.0.3. When doing this, the modules for openai and azure openai should be separated from gemini's modules so that unnecessary dependencies won't happen while those components has the same interface. But migration is easy. Basically only thing to do is to change import modules level like from langrila import OpenAIChatModule
to from langrila.openai import OpenAIChatModule
. It's the same as other modules related to openai api.
Second change point is return type of stream()
and astream()
method. From v0.0.3, all return types of all chunks is CompletionResults.
Third point is the name of results class : RetrievalResult
to RetrievalResults
. RetrievalResults
model has collections atribute now. Also similarities was replaced with scores.
Sample notebook 01.introduction.ipynb includes following contents:
- Basic usage with simple text prompt
- Chat Completion of OpenAI
- Chat Completion on Azure OpenAI
- Gemini of Google AI
- Gemini on VertexAI
- Claude of Anthropic
- Claude on Amazon Bedrock
- Message system in langrila
- Multi-turn conversation with multiple client
- How to specify system instruction
- Token management
- Usage gathering across multiple models
- Prompt template
02.function_calling.ipynb instruct function calling in langrila.
- Basic usage for OpenAI Chat Completion, Gemini and Claude
- Multi-turn conversation using tools
- Multi-turn conversation using tools with multiple client
03.structured_output.ipynb, you can see:
- JSON mode output for OpenAI and Gemini
- Pydantic schema output for OpenAI
04.media_and_file_input.ipynb show you the following contents:
- Image input
- PDF file input
- Video input
- Data uploading and analyzing by specifying uri for Gemini
- Python >=3.10,<3.13
Langrila has various extra installation options. See the following installation section and pyproject.toml.
git clone [email protected]:taikinman/langrila.git
See pyproject.toml for more detailed installation options.
cd langrila
# For OpenAI
pip install -e .[openai]
# For Gemini
pip install -e .[gemini]
# For Claude
pip install -e .[claude]
# For both
pip install -e .[openai,gemini]
# For OpenAI and Qdrant
pip install -e .[openai,qdrant]
# For OpenAI and Chroma
pip install -e .[openai,chroma]
# For OpenAI and Usearch
pip install -e .[openai,usearch]
# For All
pip install -e .[all]
See pyproject.toml for more detailed installation options.
# For OpenAI
poetry add --editable /path/to/langrila/ --extras openai
# For Gemini
poetry add --editable /path/to/langrila/ --extras gemini
# For Claude
poetry add --editable /path/to/langrila/ --extras claude
# For both OpenAI and Gemini (can choose Claude as well)
poetry add --editable /path/to/langrila/ --extras "openai gemini"
# For OpenAI and Qdrant
poetry add --editable /path/to/langrila/ --extras "openai qdrant"
# For OpenAI and Chroma
poetry add --editable /path/to/langrila/ --extras "openai chroma"
# For OpenAI and Usearch
poetry add --editable /path/to/langrila/ --extras "openai usearch"
# For all extra dependencies
poetry add --editable /path/to/langrila/ --extras all
Now langrila supports qdrant, chroma and usearch for retrieval.
from qdrant_client import models
from langrila.database.qdrant import QdrantLocalCollectionModule, QdrantLocalRetrievalModule
from langrila.openai import OpenAIEmbeddingModule
#######################
# create collection
#######################
embedder = OpenAIEmbeddingModule(
api_key_env_name="API_KEY",
model_name="text-embedding-3-small",
dimensions=1536,
)
collection = QdrantLocalCollectionModule(
persistence_directory="./qdrant_test",
collection_name="sample",
embedder=embedder,
vectors_config=models.VectorParams(
size=1536,
distance=models.Distance.COSINE,
),
)
documents = [
"Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.",
"LangChain is a framework for developing applications powered by language models.",
"LlamaIndex (GPT Index) is a data framework for your LLM application.",
]
collection.run(documents=documents) # metadatas could also be used
# #######################
# # retrieval
# #######################
# In the case collection was already instantiated
# retriever = collection.as_retriever(n_results=2, threshold_similarity=0.5)
retriever = QdrantLocalRetrievalModule(
embedder=embedder,
persistence_directory="./qdrant_test",
collection_name="sample",
n_results=2,
score_threshold=0.5,
)
query = "What is Langrila?"
retrieval_reuslt = retriever.run(query, filter=None)
# show result
retrieval_result.model_dump()
>>> {'ids': [0],
'documents': ['Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'],
'metadatas': [{'document': 'Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'}],
'scores': [0.5303465176248179],
'collections': ['sample'],
'usage': {'prompt_tokens': 6, 'completion_tokens': 0}}
Qdrant server is also supported by QdrantRemoteCollectionModule
and QdrantRemoteRetrievalModule
. Here is a basic example using docker which app container and qdrant container are bridged by same network.
from qdrant_client import models
from langrila.database.qdrant import QdrantRemoteCollectionModule, QdrantRemoteRetrievalModule
from langrila.openai import OpenAIEmbeddingModule
#######################
# create collection
#######################
embedder = OpenAIEmbeddingModule(
api_key_env_name="API_KEY",
model_name="text-embedding-3-small",
dimensions=1536,
)
collection = QdrantRemoteCollectionModule(
url="http://qdrant",
port="6333",
collection_name="sample",
embedder=embedder,
vectors_config=models.VectorParams(
size=1536,
distance=models.Distance.COSINE,
),
)
For more details, see qdrant.py.
from langrila.database.chroma import ChromaLocalCollectionModule, ChromaLocalRetrievalModule
from langrila.openai import OpenAIEmbeddingModule
#######################
# create collection
#######################
embedder = OpenAIEmbeddingModule(
api_key_env_name="API_KEY",
model_name="text-embedding-3-small",
dimensions=1536,
)
collection = ChromaLocalCollectionModule(
persistence_directory="./chroma_test",
collection_name="sample",
embedder=embedder,
)
documents = [
"Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.",
"LangChain is a framework for developing applications powered by language models.",
"LlamaIndex (GPT Index) is a data framework for your LLM application.",
]
collection.run(documents=documents) # metadatas could also be used
# #######################
# # retrieval
# #######################
# In the case collection was already instantiated
# retriever = collection.as_retriever(n_results=2, threshold_similarity=0.5)
retriever = ChromaLocalRetrievalModule(
embedder=embedder,
persistence_directory="./chroma_test",
collection_name="sample",
n_results=2,
score_threshold=0.5,
)
query = "What is Langrila?"
retrieval_result = retriever.run(query, filter=None)
# show result
retrieval_result.model_dump()
>>> {'ids': [0],
'documents': ['Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'],
'metadatas': [{'document': 'Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'}],
'scores': [0.46960276455443584],
'collections': ['sample'],
'usage': {'prompt_tokens': 6, 'completion_tokens': 0}}
HttpClient is also supported by ChromaRemoteCollectionModule
and ChromaRemoteRetrievalModule
. Here is a basic example using docker which app container and chroma container are bridged by same network.
from langrila.database.chroma import ChromaRemoteCollectionModule
from langrila.openai import OpenAIEmbeddingModule
#######################
# create collection
#######################
embedder = OpenAIEmbeddingModule(
api_key_env_name="API_KEY",
model_name="text-embedding-3-small",
dimensions=1536,
)
collection = ChromaRemoteCollectionModule(
host="chroma",
port="8000",
collection_name="sample",
embedder=embedder,
)
For more details, see chroma.py.
Usearch originally doesn't support metadata storing and filtering, so in langrila, those functions are realized by SQLite3 and postprocessing.
from langrila.database.usearch import UsearchLocalCollectionModule, UsearchLocalRetrievalModule
from langrila.openai import OpenAIEmbeddingModule
#######################
# create collection
#######################
embedder = OpenAIEmbeddingModule(
api_key_env_name="API_KEY",
model_name="text-embedding-3-small",
dimensions=1536,
)
collection = UsearchLocalCollectionModule(
persistence_directory="./usearch_test",
collection_name="sample",
embedder=embedder,
dtype = "f16",
ndim = 1536,
connectivity = 16,
expansion_add = 128,
expansion_search = 64,
)
documents = [
"Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.",
"LangChain is a framework for developing applications powered by language models.",
"LlamaIndex (GPT Index) is a data framework for your LLM application.",
]
# Strongly recommended because search result may be different when new vectors are inserted after existing vectors are removed.
# Instead, rebuilding the index is recommended using `delete_collection` before upserting.
# Or use exact search to avoid this issue when search time.
collection.delete_collection()
collection.run(documents=documents) # metadatas could also be used.
# #######################
# # retrieval
# #######################
# In the case collection was already instantiated
# retriever = collection.as_retriever(n_results=2, threshold_similarity=0.5)
retriever = UsearchLocalRetrievalModule(
embedder=embedder,
persistence_directory="./usearch_test",
collection_name="sample",
dtype = "f16",
ndim=1536,
connectivity = 16,
expansion_add = 128,
expansion_search = 64,
n_results=2,
score_threshold=0.5,
)
query = "What is Langrila?"
retrieval_result = retriever.run(query, filter=None, exact=False)
# show result
retrieval_result.model_dump()
>>> {'ids': [0],
'documents': ['Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'],
'metadatas': [{'document': 'Langrila is a useful tool to use ChatGPT with OpenAI API or Azure in an easy way.'}],
'scores': [0.46986961364746094],
'collections': ['sample'],
'usage': {'prompt_tokens': 6, 'completion_tokens': 0}}
When you need to filter retrieval results by metadata in search time, you can implement your custom metadata filter. Base class of metadata filter is in base.py. For more details, see : usearch.py.
The library supports a variety of use cases by combining modules such as these and defining new modules. For example, the following is an example of a module that combines basic Retrieval and prompt templates.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for langrila
Similar Open Source Tools
langrila
Langrila is a library that provides an easy way to use API-based LLM (Large Language Models) with an emphasis on simple architecture for readability. It supports various AI models for chat and embedding tasks, as well as retrieval functionalities using Qdrant, Chroma, and Usearch. Langrila also includes modules for function calling, conversation memory management, and prompt templates. It enforces coding policies for simplicity, responsibility independence, and minimum module implementation. The library requires Python version 3.10 to 3.13 and additional dependencies like OpenAI, Gemini, Qdrant, Chroma, and Usearch for specific functionalities.
flow-prompt
Flow Prompt is a dynamic library for managing and optimizing prompts for large language models. It facilitates budget-aware operations, dynamic data integration, and efficient load distribution. Features include CI/CD testing, dynamic prompt development, multi-model support, real-time insights, and prompt testing and evolution.
SimplerLLM
SimplerLLM is an open-source Python library that simplifies interactions with Large Language Models (LLMs) for researchers and beginners. It provides a unified interface for different LLM providers, tools for enhancing language model capabilities, and easy development of AI-powered tools and apps. The library offers features like unified LLM interface, generic text loader, RapidAPI connector, SERP integration, prompt template builder, and more. Users can easily set up environment variables, create LLM instances, use tools like SERP, generic text loader, calling RapidAPI APIs, and prompt template builder. Additionally, the library includes chunking functions to split texts into manageable chunks based on different criteria. Future updates will bring more tools, interactions with local LLMs, prompt optimization, response evaluation, GPT Trainer, document chunker, advanced document loader, integration with more providers, Simple RAG with SimplerVectors, integration with vector databases, agent builder, and LLM server.
mlx-llm
mlx-llm is a library that allows you to run Large Language Models (LLMs) on Apple Silicon devices in real-time using Apple's MLX framework. It provides a simple and easy-to-use API for creating, loading, and using LLM models, as well as a variety of applications such as chatbots, fine-tuning, and retrieval-augmented generation.
embodied-agents
Embodied Agents is a toolkit for integrating large multi-modal models into existing robot stacks with just a few lines of code. It provides consistency, reliability, scalability, and is configurable to any observation and action space. The toolkit is designed to reduce complexities involved in setting up inference endpoints, converting between different model formats, and collecting/storing datasets. It aims to facilitate data collection and sharing among roboticists by providing Python-first abstractions that are modular, extensible, and applicable to a wide range of tasks. The toolkit supports asynchronous and remote thread-safe agent execution for maximal responsiveness and scalability, and is compatible with various APIs like HuggingFace Spaces, Datasets, Gymnasium Spaces, Ollama, and OpenAI. It also offers automatic dataset recording and optional uploads to the HuggingFace hub.
sparkle
Sparkle is a tool that streamlines the process of building AI-driven features in applications using Large Language Models (LLMs). It guides users through creating and managing agents, defining tools, and interacting with LLM providers like OpenAI. Sparkle allows customization of LLM provider settings, model configurations, and provides a seamless integration with Sparkle Server for exposing agents via an OpenAI-compatible chat API endpoint.
iceburgcrm
Iceburg CRM is a metadata driven CRM with AI abilities that allows users to quickly prototype any CRM. It offers features like metadata creations, import/export in multiple formats, field validation, themes, role permissions, calendar, audit logs, API, workflow, field level relationships, module level relationships, and more. Created with Vue 3 for the frontend, Laravel 10 for the backend, Tailwinds with DaisyUI plugin, and Inertia for routing. Users can install default, admin panel, core, custom, or AI versions. The tool supports AI Assist for module data suggestions and provides API endpoints for CRM modules, search, specific module data, record updates, and deletions. Iceburg CRM also includes themes, custom field types, calendar, datalets, workflow, roles and permissions, import/export functionality, and custom seeding options.
PhoGPT
PhoGPT is an open-source 4B-parameter generative model series for Vietnamese, including the base pre-trained monolingual model PhoGPT-4B and its chat variant, PhoGPT-4B-Chat. PhoGPT-4B is pre-trained from scratch on a Vietnamese corpus of 102B tokens, with an 8192 context length and a vocabulary of 20K token types. PhoGPT-4B-Chat is fine-tuned on instructional prompts and conversations, demonstrating superior performance. Users can run the model with inference engines like vLLM and Text Generation Inference, and fine-tune it using llm-foundry. However, PhoGPT has limitations in reasoning, coding, and mathematics tasks, and may generate harmful or biased responses.
clarifai-python
The Clarifai Python SDK offers a comprehensive set of tools to integrate Clarifai's AI platform to leverage computer vision capabilities like classification , detection ,segementation and natural language capabilities like classification , summarisation , generation , Q&A ,etc into your applications. With just a few lines of code, you can leverage cutting-edge artificial intelligence to unlock valuable insights from visual and textual content.
videokit
VideoKit is a full-featured user-generated content solution for Unity Engine, enabling video recording, camera streaming, microphone streaming, social sharing, and conversational interfaces. It is cross-platform, with C# source code available for inspection. Users can share media, save to camera roll, pick from camera roll, stream camera preview, record videos, remove background, caption audio, and convert text commands. VideoKit requires Unity 2022.3+ and supports Android, iOS, macOS, Windows, and WebGL platforms.
exo
Run your own AI cluster at home with everyday devices. Exo is experimental software that unifies existing devices into a powerful GPU, supporting wide model compatibility, dynamic model partitioning, automatic device discovery, ChatGPT-compatible API, and device equality. It does not use a master-worker architecture, allowing devices to connect peer-to-peer. Exo supports different partitioning strategies like ring memory weighted partitioning. Installation is recommended from source. Documentation includes example usage on multiple MacOS devices and information on inference engines and networking modules. Known issues include the iOS implementation lagging behind Python.
syncode
SynCode is a novel framework for the grammar-guided generation of Large Language Models (LLMs) that ensures syntactically valid output with respect to defined Context-Free Grammar (CFG) rules. It supports general-purpose programming languages like Python, Go, SQL, JSON, and more, allowing users to define custom grammars using EBNF syntax. The tool compares favorably to other constrained decoders and offers features like fast grammar-guided generation, compatibility with HuggingFace Language Models, and the ability to work with various decoding strategies.
amadeus-python
Amadeus Python SDK provides a rich set of APIs for the travel industry. It allows users to make API calls for various travel-related tasks such as flight offers search, hotel bookings, trip purpose prediction, flight delay prediction, airport on-time performance, travel recommendations, and more. The SDK conveniently maps API paths to similar paths, making it easy to interact with the Amadeus APIs. Users can initialize the client with their API key and secret, make API calls, handle responses, and enable logging for debugging purposes. The SDK documentation includes detailed information about each SDK method, arguments, and return types.
fragments
Fragments is an open-source tool that leverages Anthropic's Claude Artifacts, Vercel v0, and GPT Engineer. It is powered by E2B Sandbox SDK and Code Interpreter SDK, allowing secure execution of AI-generated code. The tool is based on Next.js 14, shadcn/ui, TailwindCSS, and Vercel AI SDK. Users can stream in the UI, install packages from npm and pip, and add custom stacks and LLM providers. Fragments enables users to build web apps with Python interpreter, Next.js, Vue.js, Streamlit, and Gradio, utilizing providers like OpenAI, Anthropic, Google AI, and more.
cursive-py
Cursive is a universal and intuitive framework for interacting with LLMs. It is extensible, allowing users to hook into any part of a completion life cycle. Users can easily describe functions that LLMs can use with any supported model. Cursive aims to bridge capabilities between different models, providing a single interface for users to choose any model. It comes with built-in token usage and costs calculations, automatic retry, and model expanding features. Users can define and describe functions, generate Pydantic BaseModels, hook into completion life cycle, create embeddings, and configure retry and model expanding behavior. Cursive supports various models from OpenAI, Anthropic, OpenRouter, Cohere, and Replicate, with options to pass API keys for authentication.
instructor
Instructor is a popular Python library for managing structured outputs from large language models (LLMs). It offers a user-friendly API for validation, retries, and streaming responses. With support for various LLM providers and multiple languages, Instructor simplifies working with LLM outputs. The library includes features like response models, retry management, validation, streaming support, and flexible backends. It also provides hooks for logging and monitoring LLM interactions, and supports integration with Anthropic, Cohere, Gemini, Litellm, and Google AI models. Instructor facilitates tasks such as extracting user data from natural language, creating fine-tuned models, managing uploaded files, and monitoring usage of OpenAI models.
For similar tasks
langrila
Langrila is a library that provides an easy way to use API-based LLM (Large Language Models) with an emphasis on simple architecture for readability. It supports various AI models for chat and embedding tasks, as well as retrieval functionalities using Qdrant, Chroma, and Usearch. Langrila also includes modules for function calling, conversation memory management, and prompt templates. It enforces coding policies for simplicity, responsibility independence, and minimum module implementation. The library requires Python version 3.10 to 3.13 and additional dependencies like OpenAI, Gemini, Qdrant, Chroma, and Usearch for specific functionalities.
lunary
Lunary is an open-source observability and prompt platform for Large Language Models (LLMs). It provides a suite of features to help AI developers take their applications into production, including analytics, monitoring, prompt templates, fine-tuning dataset creation, chat and feedback tracking, and evaluations. Lunary is designed to be usable with any model, not just OpenAI, and is easy to integrate and self-host.
minimal-llm-ui
This minimalistic UI serves as a simple interface for Ollama models, enabling real-time interaction with Local Language Models (LLMs). Users can chat with models, switch between different LLMs, save conversations, and create parameter-driven prompt templates. The tool is built using React, Next.js, and Tailwind CSS, with seamless integration with LangchainJs and Ollama for efficient model switching and context storage.
For similar jobs
promptflow
**Prompt flow** is a suite of development tools designed to streamline the end-to-end development cycle of LLM-based AI applications, from ideation, prototyping, testing, evaluation to production deployment and monitoring. It makes prompt engineering much easier and enables you to build LLM apps with production quality.
deepeval
DeepEval is a simple-to-use, open-source LLM evaluation framework specialized for unit testing LLM outputs. It incorporates various metrics such as G-Eval, hallucination, answer relevancy, RAGAS, etc., and runs locally on your machine for evaluation. It provides a wide range of ready-to-use evaluation metrics, allows for creating custom metrics, integrates with any CI/CD environment, and enables benchmarking LLMs on popular benchmarks. DeepEval is designed for evaluating RAG and fine-tuning applications, helping users optimize hyperparameters, prevent prompt drifting, and transition from OpenAI to hosting their own Llama2 with confidence.
MegaDetector
MegaDetector is an AI model that identifies animals, people, and vehicles in camera trap images (which also makes it useful for eliminating blank images). This model is trained on several million images from a variety of ecosystems. MegaDetector is just one of many tools that aims to make conservation biologists more efficient with AI. If you want to learn about other ways to use AI to accelerate camera trap workflows, check out our of the field, affectionately titled "Everything I know about machine learning and camera traps".
leapfrogai
LeapfrogAI is a self-hosted AI platform designed to be deployed in air-gapped resource-constrained environments. It brings sophisticated AI solutions to these environments by hosting all the necessary components of an AI stack, including vector databases, model backends, API, and UI. LeapfrogAI's API closely matches that of OpenAI, allowing tools built for OpenAI/ChatGPT to function seamlessly with a LeapfrogAI backend. It provides several backends for various use cases, including llama-cpp-python, whisper, text-embeddings, and vllm. LeapfrogAI leverages Chainguard's apko to harden base python images, ensuring the latest supported Python versions are used by the other components of the stack. The LeapfrogAI SDK provides a standard set of protobuffs and python utilities for implementing backends and gRPC. LeapfrogAI offers UI options for common use-cases like chat, summarization, and transcription. It can be deployed and run locally via UDS and Kubernetes, built out using Zarf packages. LeapfrogAI is supported by a community of users and contributors, including Defense Unicorns, Beast Code, Chainguard, Exovera, Hypergiant, Pulze, SOSi, United States Navy, United States Air Force, and United States Space Force.
llava-docker
This Docker image for LLaVA (Large Language and Vision Assistant) provides a convenient way to run LLaVA locally or on RunPod. LLaVA is a powerful AI tool that combines natural language processing and computer vision capabilities. With this Docker image, you can easily access LLaVA's functionalities for various tasks, including image captioning, visual question answering, text summarization, and more. The image comes pre-installed with LLaVA v1.2.0, Torch 2.1.2, xformers 0.0.23.post1, and other necessary dependencies. You can customize the model used by setting the MODEL environment variable. The image also includes a Jupyter Lab environment for interactive development and exploration. Overall, this Docker image offers a comprehensive and user-friendly platform for leveraging LLaVA's capabilities.
carrot
The 'carrot' repository on GitHub provides a list of free and user-friendly ChatGPT mirror sites for easy access. The repository includes sponsored sites offering various GPT models and services. Users can find and share sites, report errors, and access stable and recommended sites for ChatGPT usage. The repository also includes a detailed list of ChatGPT sites, their features, and accessibility options, making it a valuable resource for ChatGPT users seeking free and unlimited GPT services.
TrustLLM
TrustLLM is a comprehensive study of trustworthiness in LLMs, including principles for different dimensions of trustworthiness, established benchmark, evaluation, and analysis of trustworthiness for mainstream LLMs, and discussion of open challenges and future directions. Specifically, we first propose a set of principles for trustworthy LLMs that span eight different dimensions. Based on these principles, we further establish a benchmark across six dimensions including truthfulness, safety, fairness, robustness, privacy, and machine ethics. We then present a study evaluating 16 mainstream LLMs in TrustLLM, consisting of over 30 datasets. The document explains how to use the trustllm python package to help you assess the performance of your LLM in trustworthiness more quickly. For more details about TrustLLM, please refer to project website.
AI-YinMei
AI-YinMei is an AI virtual anchor Vtuber development tool (N card version). It supports fastgpt knowledge base chat dialogue, a complete set of solutions for LLM large language models: [fastgpt] + [one-api] + [Xinference], supports docking bilibili live broadcast barrage reply and entering live broadcast welcome speech, supports Microsoft edge-tts speech synthesis, supports Bert-VITS2 speech synthesis, supports GPT-SoVITS speech synthesis, supports expression control Vtuber Studio, supports painting stable-diffusion-webui output OBS live broadcast room, supports painting picture pornography public-NSFW-y-distinguish, supports search and image search service duckduckgo (requires magic Internet access), supports image search service Baidu image search (no magic Internet access), supports AI reply chat box [html plug-in], supports AI singing Auto-Convert-Music, supports playlist [html plug-in], supports dancing function, supports expression video playback, supports head touching action, supports gift smashing action, supports singing automatic start dancing function, chat and singing automatic cycle swing action, supports multi scene switching, background music switching, day and night automatic switching scene, supports open singing and painting, let AI automatically judge the content.