## File: README.md

# llmware


[](https://discord.gg/bphreFK4NJ)
[](https://github.com/llmware-ai/llmware/actions/workflows/pages.yml)  

## 🧰🛠️ Unified framework for building knowledge-based local, private, secure LLM-based applications       

`llmware` is optimized for AI PC and local laptop, edge and self-hosted deployment across a wide range of Windows, Mac and Linux platforms, with support for GGUF, OpenVINO, ONNXRuntime, ONNXRuntime-QNN (Qualcomm), WindowsLocalFoundry, and Pytorch, providing a high-level interface that makes it easy to leverage the right inferencing technology optimized for the target platform.  

 `llmware` has two main components:  

 1.  **Model catalog with 300+ models** - models prepackaged in quantized, optimized formats, to leverage on device GPU and NPU capabilities, with support for major open source model families and 50+ llmware finetuned SLIM, Bling, Dragon and Industry-Bert models specialized for key tasks in enterprise process automation.  Also supports leading cloud models from OpenAI, Anthropic and Google.  
 
 2.  **RAG Pipeline** - integrated components for the full lifecycle of connecting knowledge sources to generative AI models with wide range of document parsing and ingestion capabilities, and the ability to create scalable knowledge bases.

By bringing together both of these components,  `llmware` offers a comprehensive set of tools to rapidly build knowledge-based enterprise LLM applications.  

Our vision is that AI should be sustainable, accurate, and cost-effective, using the smallest possible compute footprint to get the job done.  

Virtually all of our examples and models can be run on device - get started right away on your laptop.   

[Join us on Discord](https://discord.gg/MhZn5Nc39h)   |  [Watch Youtube Tutorials](https://www.youtube.com/@llmware)  | [Explore our Model Families on Huggingface](https://www.huggingface.co/llmware)   


## 🎯  Key features 
Writing code with`llmware` is based on a few main concepts:


**Model Catalog**: Access all models the same way with easy lookup, regardless of underlying implementation. 
  


```python
#   300+ Models in Catalog with 50+ RAG-optimized BLING, DRAGON and Industry BERT models
#   Full support for GGUF, OpenVINO, Onnxruntime, HuggingFace, Sentence Transformers and major API-based models
#   Easy to extend to add custom models - see examples

from llmware.models import ModelCatalog
from llmware.prompts import Prompt

#   all models accessed through the ModelCatalog
models = ModelCatalog().list_all_models()

#   to use any model in the ModelCatalog - "load_model" method and pass the model_name parameter
my_model = ModelCatalog().load_model("llmware/bling-phi-3-gguf")

#   call model with: inference 
output = my_model.inference("what is the future of AI?", add_context="Here is the article to read")

#   call model with: stream
for token in my_model.stream("What is the future of AI?"):
    print(token, end="")

#   to integrate model into a Prompt
prompter = Prompt().load_model("llmware/bling-tiny-llama-v0")
response = prompter.prompt_main("what is the future of AI?", context="Insert Sources of information")
```

  

  
**Library**:  ingest, organize and index a collection of knowledge at scale - Parse, Text Chunk and Embed.   

```python

from llmware.library import Library

#   to parse and text chunk a set of documents (pdf, pptx, docx, xlsx, txt, csv, md, json/jsonl, wav, png, jpg, html)  

#   step 1 - create a library, which is the 'knowledge-base container' construct
#          - libraries have both text collection (DB) resources, and file resources (e.g., llmware_data/accounts/{library_name})
#          - embeddings and queries are run against a library

lib = Library().create_new_library("my_library")

#    step 2 - add_files is the universal ingestion function - point it at a local file folder with mixed file types
#           - files will be routed by file extension to the correct parser, parsed, text chunked and indexed in text collection DB

lib.add_files("/folder/path/to/my/files")

#   to install an embedding on a library - pick an embedding model and vector_db
lib.install_new_embedding(embedding_model_name="mini-lm-sbert", vector_db="milvus", batch_size=500)

#   to add a second embedding to the same library (mix-and-match models + vector db)  
lib.install_new_embedding(embedding_model_name="industry-bert-sec", vector_db="chromadb", batch_size=100)

#   easy to create multiple libraries for different projects and groups

finance_lib = Library().create_new_library("finance_q4_2023")
finance_lib.add_files("/finance_folder/")

hr_lib = Library().create_new_library("hr_policies")
hr_lib.add_files("/hr_folder/")

#    pull library card with key metadata - documents, text chunks, images, tables, embedding record
lib_card = Library().get_library_card("my_library")

#   see all libraries
all_my_libs = Library().get_all_library_cards()

```
  

 
**Query**: query libraries with mix of text, semantic, hybrid, metadata, and custom filters. 

```python

from llmware.retrieval import Query
from llmware.library import Library

#   step 1 - load the previously created library 
lib = Library().load_library("my_library")

#   step 2 - create a query object and pass the library
q = Query(lib)

#    step 3 - run lots of different queries  (many other options in the examples)

#    basic text query
results1 = q.text_query("text query", result_count=20, exact_mode=False)

#    semantic query
results2 = q.semantic_query("semantic query", result_count=10)

#    combining a text query restricted to only certain documents in the library and "exact" match to the query
results3 = q.text_query_with_document_filter("new query", {"file_name": "selected file name"}, exact_mode=True)

#   to apply a specific embedding (if multiple on library), pass the names when creating the query object
q2 = Query(lib, embedding_model_name="mini_lm_sbert", vector_db="milvus")
results4 = q2.semantic_query("new semantic query")
```

  


**Prompt with Sources**: the easiest way to combine knowledge retrieval with a LLM inference. 

```python

from llmware.prompts import Prompt
from llmware.retrieval import Query
from llmware.library import Library

#   build a prompt
prompter = Prompt().load_model("llmware/bling-tiny-llama-v0")

#   add a file -> file is parsed, text chunked, filtered by query, and then packaged as model-ready context,
#   including in batches, if needed, to fit the model context window

source = prompter.add_source_document("/folder/to/one/doc/", "filename", query="fast query")

#   attach query results (from a Query) into a Prompt
my_lib = Library().load_library("my_library")
results = Query(my_lib).query("my query")
source2 = prompter.add_source_query_results(results)

#   run a new query against a library and load directly into a prompt
source3 = prompter.add_source_new_query(my_lib, query="my new query", query_type="semantic", result_count=15)

#   to run inference with 'prompt with sources'
responses = prompter.prompt_with_source("my query")

#   to run fact-checks - post inference
fact_check = prompter.evidence_check_sources(responses)

#   to view source materials (batched 'model-ready' and attached to prompt)
source_materials = prompter.review_sources_summary()

#   to see the full prompt history
prompt_history = prompter.get_current_history()
```

  

 
**RAG-Optimized Models** -  1-7B parameter models designed for RAG workflow integration and running locally.   

```
/* Detailed source-code truncated for AI context efficiency. */
```




**Simple-to-Scale Database Options ** - integrated data stores from laptop to parallelized cluster. 

```python

from llmware.configs import LLMWareConfig

#   to set the collection database - mongo, sqlite, postgres  
LLMWareConfig().set_active_db("mongo")  

#   to set the vector database (or declare when installing)  
#   --options: milvus, pg_vector (postgres), redis, qdrant, faiss, pinecone, mongo atlas  
LLMWareConfig().set_vector_db("milvus")  

#   for fast start - no installations required  
LLMWareConfig().set_active_db("sqlite")  
LLMWareConfig().set_vector_db("chromadb")   # try also faiss and lancedb  

#   for single postgres deployment  
LLMWareConfig().set_active_db("postgres")  
LLMWareConfig().set_vector_db("postgres")  

#   to install mongo, milvus, postgres - see the docker-compose scripts as well as examples

```





 ** Agents with Function Calls and SLIM Models **   

```python

from llmware.agents import LLMfx

text = ("Tesla stock fell 8% in premarket trading after reporting fourth-quarter revenue and profit that "
        "missed analysts’ estimates. The electric vehicle company also warned that vehicle volume growth in "
        "2024 'may be notably lower' than last year’s growth rate. Automotive revenue, meanwhile, increased "
        "just 1% from a year earlier, partly because the EVs were selling for less than they had in the past. "
        "Tesla implemented steep price cuts in the second half of the year around the world. In a Wednesday "
        "presentation, the company warned investors that it’s 'currently between two major growth waves.'")

#   create an agent using LLMfx class
agent = LLMfx()

#   load text to process
agent.load_work(text)

#   load 'models' as 'tools' to be used in analysis process
agent.load_tool("sentiment")
agent.load_tool("extract")
agent.load_tool("topics")
agent.load_tool("boolean")

#   run function calls using different tools
agent.sentiment()
agent.topics()
agent.extract(params=["company"])
agent.extract(params=["automotive revenue growth"])
agent.xsum()
agent.boolean(params=["is 2024 growth expected to be strong? (explain)"])

#   at end of processing, show the report that was automatically aggregated by key
report = agent.show_report()

#   displays a summary of the activity in the process
activity_summary = agent.activity_summary()

#   list of the responses gathered
for i, entries in enumerate(agent.response_list):
    print("update: response analysis: ", i, entries)

output = {"report": report, "activity_summary": activity_summary, "journal": agent.journal}  

```




 🚀 **Start coding - Quick Start for RAG ** 

```
/* Detailed source-code truncated for AI context efficiency. */
```


## 🔥 Solutions

For project ideas, please see [solutions](https://github.com/llmware-ai/llmware/tree/main/solutions) with dozens of innovative examples.  

### OpenVINO Encoders - ideal for on-device, efficient RAG:

- 20 OV-optimized encoding models with OVEmbeddingModel class - supports wide of embedding, reranker and classifers, e.g.,  
- [using_openvino_embedding_model](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_embedding_model.py)  
- [using_openvino_reranker_model](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_reranker_model.py)  
- [using_openvino_classifier_model](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_classifier_model.py)  

### ONNXRuntime Reranker - use rerankers optimized for Onnxruntime deployment   

- [using_onnx_reranker_model](https://github.com/llmware-ai/llmware/blob/main/solutions/onnxruntime/using_onnx_reranker_models.py)   
  
### WindowsLocalFoundry integration - use WindowsLocalFoundry models in llmware  

- [using_local_foundry_model](https://github.com/llmware-ai/llmware/blob/main/solutions/onnxruntime/using_local_foundry_models.py)  

### Model Depot - largest out-of-the-box collection of OpenVINO-based LLMs (95+)   

- [Model Depot on Huggingface](https://huggingface.co/collections/llmware/model-depot)   
- [using_stream_generation_with_openvino](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_streamer.py)     
- [getting_started_with_openvino](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_models.py)  

### Image Generation - Multimedia Bot  

- [multimedia-bot example](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/multimedia_bot.py)  

### ONNXRuntime-QNN - run models on Snapdragon NPU (Windows Arm64) 

- 7 NPU-optimized models 'ready to run' in Model Catalog - see [using-qnn-npu-models example](https://github.com/llmware-ai/llmware/tree/main/solutions/onnxruntime/using-qnn-npu-models.py)  

### Industry-specific Embedding Models for Specialized RAG 

- Check out the LLMware Industry Bert model series - see [industry-bert-models](https://huggingface.co/collections/llmware/industry-bert-models)  

### Audio & Text Processing

- **Voice Transcription with WhisperCPP**  
  Start transcription projects with WhisperCPP, featuring tools for sample file usage and famous speeches.
  - [Getting started guide](solutions/gguf/using-whisper-cpp-getting-started.py) | [Parsing great speeches](solutions/gguf/parsing_great_speeches.py) | [Demo video](https://youtu.be/5y0ez5ZBpPE?si=KVxsXXtX5TzvlEws)

- **Natural Language Query to CSV**  
  Convert natural language queries to CSV with Slim-SQL, supporting custom Postgres tables.
  - [Demo video](https://youtu.be/z48z5XOXJJg?si=V-CX1w-7KRioI4Bi) | [End-to-end example](solutions/slim_agents/text2sql-end-to-end-2.py) | [Custom table usage](https://github.com/llmware-ai/llmware/tree/main/solutions/slim_agents/agent_with_custom_tables.py)

### Multi-Model Agents

- **Multi-Model Agents with SLIM**  
  Use SLIM models on CPU for multi-step agents in complex workflows.
  - [Demo video](https://www.youtube.com/watch?v=cQfdaTcmBpY) | [Example directory](solutions/slim_agents)

### Document & OCR Processing

- **OCR Embedded Document Images**  
  Extract text systematically from images embedded in documents for enhanced document processing.
  - [OCR example](solutions/sources/ocr_embedded_doc_images.py)

- **Enhanced Document Parsing for PDFs, Word, PowerPoint, and Excel**  
  Improved text-chunking controls, table extraction, and content parsing.
  - [Parsing example](solutions/sources/pdf_parser_new_configs.py)

- **Optimizing Accuracy of RAG Prompts**  
  Tutorials for tuning RAG prompt settings for increased accuracy.
  - [Settings example](solutions/models/adjusting_sampling_settings.py) | Videos: [Part I](https://youtu.be/7oMTGhSKuNY?si=14mS2pftk7NoKQbC), [Part II](https://youtu.be/iXp1tj-pPjM?si=T4teUAISnSWgtThu)  
  
New to RAG?  [Check out the Fast Start video series](https://www.youtube.com/playlist?list=PL1-dn33KwsmD7SB9iSO6vx4ZLRAWea1DB)  

[Intro to SLIM Function Call Models](https://github.com/llmware-ai/llmware/blob/main/solutions/models/using_function_calls.py)  

## 🌱 Getting Started

**Step 1 - Install llmware** -  `pip3 install llmware` or `pip3 install 'llmware[full]'`  

- [core install](https://github.com/llmware-ai/llmware/blob/main/llmware/requirements.txt) (minimal set of dependencies)  
- [full install](https://github.com/llmware-ai/llmware/blob/main/llmware/requirements_extras.txt) (adds to the core with wider set of related python libraries).  


**Step 2- Go to Examples** - Get Started Fast with 100+ 'Cut-and-Paste' Recipes 

## 🔥 Top New Examples 🔥  

End-to-End Scenario - [**Function Calls with SLIM Extract and Web Services for Financial Research**](https://github.com/llmware-ai/llmware/tree/main/solutions/use_cases/web_services_slim_fx.py)  
Analyzing Voice Files - [**Great Speeches with LLM Query and Extract**](https://github.com/llmware-ai/llmware/tree/main/solutions/use_cases/parsing_great_speeches.py)  
New to LLMWare - [**Fast Start tutorial series**](https://github.com/llmware-ai/llmware/tree/main/tutorials)  
Getting Setup - [**Getting Started**](https://github.com/llmware-ai/llmware/tree/main/tutorials/Getting_Started)  
SLIM Examples -  [**SLIM Models**](solutions/slim_agents/)  

| Example     |  Detail      |
|-------------|--------------|
| 1.   BLING models fast start ([code](solutions/models/bling_fast_start.py) / [video](https://www.youtube.com/watch?v=JjgqOZ2v5oU)) | Get started with fast, accurate, CPU-based models - question-answering, key-value extraction, and basic summarization.  |
| 2.   Parse and Embed 500 PDF Documents ([code](solutions/embedding/docs2vecs_with_milvus-un_resolutions.py))  | End-to-end example for Parsing, Embedding and Querying UN Resolution documents with Milvus  |
| 3.  Hybrid Retrieval - Semantic + Text ([code](solutions/sources/dual_pass_with_custom_filter.py)) | Using 'dual pass' retrieval to combine best of semantic and text search |  
| 4.   Multiple Embeddings with PG Vector ([code](solutions/embedding/using_multiple_embeddings.py) / [video](https://www.youtube.com/watch?v=Bncvggy6m5Q)) | Comparing Multiple Embedding Models using Postgres / PG Vector |
| 5.   DRAGON GGUF Models ([code](solutions/models/dragon_gguf_fast_start.py) / [video](https://www.youtube.com/watch?v=BI1RlaIJcsc&t=130s)) | State-of-the-Art 7B RAG GGUF Models.  | 
| 6.   RAG with BLING ([code](solutions/use_cases/contract_analysis_on_laptop_with_bling_models.py) / [video](https://www.youtube.com/watch?v=8aV5p3tErP0)) | Using contract analysis as an example, experiment with RAG for complex document analysis and text extraction using `llmware`'s BLING ~1B parameter GPT model running on your laptop. |  
| 7.   Master Service Agreement Analysis with DRAGON ([code](solutions/use_cases/msa_processing.py) / [video](https://www.youtube.com/watch?v=Cf-07GBZT68&t=2s)) | Analyzing MSAs using DRAGON YI 6B Model.   |                                                                                                                         
| 8.   Streamlit Example ([code](solutions/ui/simple_rag_ui_with_streamlit.py))  | Ask questions to Invoices with UI run inference.  |  
| 9.   Integrating LM Studio ([code](solutions/models/using-open-chat-models.py) / [video](https://www.youtube.com/watch?v=h2FDjUyvsKE&t=101s)) | Integrating LM Studio Models with LLMWare  |                                                                                                                                       
| 10.  Prompts With Sources ([code](solutions/sources/prompt_with_sources.py))  | Attach wide range of knowledge sources directly into Prompts.   |   
| 11.  Fact Checking ([code](solutions/sources/fact_checking.py))  | Explore the full set of evidence methods in this example script that analyzes a set of contracts.   |


Check out:  [llmware solutions](https://github.com/llmware-ai/llmware/blob/main/solutions/README.md)  

  


**Step 3 - Tutorial Videos** - check out our Youtube channel for high-impact 5-10 minute tutorials on the latest examples.   

🎬 Check out these videos to get started quickly:  
- [Document Summarization](https://youtu.be/Ps3W-P9A1m8?si=Rxvst3RJv8ZaOk0L)  
- [Bling-3-GGUF Local Chatbot](https://youtu.be/gzzEVK8p3VM?si=8cNn_do0oxSzCEnM)  
- [Agent-based Complex Research Analysis](https://youtu.be/y4WvwHqRR60?si=jX3KCrKcYkM95boe)  
- [Getting Started with SLIMs (with code)](https://youtu.be/aWZFrTDmMPc?si=lmo98_quo_2Hrq0C)  
- [Are you prompting wrong for RAG - Stochastic Sampling-Part I](https://youtu.be/7oMTGhSKuNY?si=_KSjuBnqArvWzYbx)  
- [Are you prompting wrong for RAG - Stochastic Sampling-Part II- Code Experiments](https://youtu.be/iXp1tj-pPjM?si=3ZeMgipY0vJDHIMY)  
- [SLIM Models Intro](https://www.youtube.com/watch?v=cQfdaTcmBpY)  
- [Text2SQL Intro](https://youtu.be/BKZ6kO2XxNo?si=tXGt63pvrp_rOlIP)  
- [RAG with BLING on your laptop](https://www.youtube.com/watch?v=JjgqOZ2v5oU)    
- [DRAGON-7B-Models](https://www.youtube.com/watch?v=d_u7VaKu6Qk&t=37s)  
- [Install and Compare Multiple Embeddings with Postgres and PGVector](https://www.youtube.com/watch?v=Bncvggy6m5Q)  
- [Background on GGUF Quantization & DRAGON Model Example](https://www.youtube.com/watch?v=ZJyQIZNJ45E)  
- [Using LM Studio Models](https://www.youtube.com/watch?v=h2FDjUyvsKE)  
- [Using Ollama Models](https://www.youtube.com/watch?v=qITahpVDuV0)  
- [Use any GGUF Model](https://www.youtube.com/watch?v=9wXJgld7Yow)  
- [Use small LLMs for RAG for Contract Analysis (feat. LLMWare)](https://www.youtube.com/watch?v=8aV5p3tErP0)
- [Invoice Processing with LLMware](https://www.youtube.com/watch?v=VHZSaBBG-Bo&t=10s)
- [Ingest PDFs at Scale](https://www.youtube.com/watch?v=O0adUfrrxi8&t=10s)
- [Evaluate LLMs for RAG with LLMWare](https://www.youtube.com/watch?v=s0KWqYg5Buk&t=105s)
- [Fast Start to RAG with LLMWare Open Source Library](https://www.youtube.com/watch?v=0naqpH93eEU)
- [Use Retrieval Augmented Generation (RAG) without a Database](https://www.youtube.com/watch?v=tAGz6yR14lw)
- [Pop up LLMWare Inference Server](https://www.youtube.com/watch?v=qiEmLnSRDUA&t=20s)


  

## ✍️ Working with the llmware Github repository  

The llmware repo can be pulled locally to get access to all the examples, or to work directly with the latest version of the llmware code.  

```bash
git clone git@github.com:llmware-ai/llmware.git
```  

We have provided a **welcome_to_llmware** automation script in the root of the repository folder.  After cloning:  
- On Windows command line:  `.\welcome_to_llmware_windows.sh`  
- On Mac / Linux command line:  `sh ./welcome_to_llmware.sh`  

Alternatively, if you prefer to complete setup without the welcome automation script, then the next steps include:  

1.  **install requirements.txt** - inside the /llmware path - e.g., ```pip3 install -r llmware/requirements.txt```  

2.  **install requirements_extras.txt** - inside the /llmware path - e.g., ```pip3 install -r llmware/requirements_extras.txt```(Depending upon your use case, you may not need all or any of these installs, but some of these will be used in the examples.)

3.  **run examples** - copy one or more of the example .py files into the root project path.   (We have seen several IDEs that will attempt to run interactively from the nested /example path, and then not have access to the /llmware module - the easy fix is to just copy the example you want to run into the root path).  

4.  **install vector db** - no-install vector db options include milvus lite, chromadb, faiss and lancedb - which do not require a server install, but do require that you install the python sdk library for that vector db, e.g., `pip3 install pymilvus`, or `pip3 install chromadb`.  If you look in [examples/Embedding](https://github.com/llmware-ai/llmware/tree/main/solutions/embedding), you will see examples for getting started with various vector DB, and in the root of the repo, you will see easy-to-get-started docker compose scripts for installing milvus, postgres/pgvector, mongo, qdrant, neo4j, and redis.  


## Data Store Options


**Fast Start**:  use SQLite3 and ChromaDB (File-based) out-of-the-box - no install required   

```python
from llmware.configs import LLMWareConfig 
LLMWareConfig().set_active_db("sqlite")   
LLMWareConfig().set_vector_db("chromadb")  
```
  


**Speed + Scale**:  use MongoDB (text collection) and Milvus (vector db) - install with Docker Compose  

```bash
curl -o docker-compose.yaml https://raw.githubusercontent.com/llmware-ai/llmware/main/docker-compose.yaml
docker compose up -d
```

```python
from llmware.configs import LLMWareConfig
LLMWareConfig().set_active_db("mongo")
LLMWareConfig().set_vector_db("milvus")
```

  


**Postgres**:  use Postgres for both text collection and vector DB - install with Docker Compose  

```bash
curl -o docker-compose.yaml https://raw.githubusercontent.com/llmware-ai/llmware/main/docker-compose-pgvector.yaml
docker compose up -d
```

```python
from llmware.configs import LLMWareConfig
LLMWareConfig().set_active_db("postgres")
LLMWareConfig().set_vector_db("postgres")
```

  


**Mix-and-Match**: LLMWare supports 3 text collection databases (Mongo, Postgres, SQLite) and 
10 vector databases (Milvus, PGVector-Postgres, Neo4j, Redis, Mongo-Atlas, Qdrant, Faiss, LanceDB, ChromaDB and Pinecone)  

```bash
# scripts to deploy other options
curl -o docker-compose.yaml https://raw.githubusercontent.com/llmware-ai/llmware/main/docker-compose-redis-stack.yaml
```

  

## Meet our Models   

- **SLIM model series:** small, specialized models fine-tuned for function calling and multi-step, multi-model Agent workflows.  
- **DRAGON model series:**  Production-grade RAG-optimized 6-9B parameter models - "Delivering RAG on ..." the leading foundation base models.  
- **BLING model series:**  Small CPU-based RAG-optimized, instruct-following 1B-5B parameter models.  
- **Industry BERT models:**  out-of-the-box custom trained sentence transformer embedding models fine-tuned for the following industries:  Insurance, Contracts, Asset Management, SEC.  
- **GGUF Quantization:** we provide 'gguf' and 'tool' versions of many SLIM, DRAGON and BLING models, optimized for CPU deployment.  


Interested in contributing to llmware? Information on ways to participate can be found in our [Contributors Guide](https://github.com/llmware-ai/llmware/blob/main/repo_docs/CONTRIBUTING.md#contributing-to-llmware).  As with all aspects of this project, contributing is governed by our [Code of Conduct](https://github.com/llmware-ai/llmware/blob/main/repo_docs/CODE_OF_CONDUCT.md).

Questions and discussions are welcome in our [github discussions](https://github.com/llmware-ai/llmware/discussions).  

## 📣  Release notes and Change Log  

For complete history of release notes, please open the Change log tab.  

**Supported Operating Systems**: Windows (x86 and Arm64), MacOS (Metal - M1-M5), Linux (x86, aarch64)    
- Linux - support Ubuntu 20+  (glibc 2.31+)   
- If you need support for another Linux version, please raise an issue - we will prioritize testing and ensure support.    

**Supported Vector Databases**: Milvus, Postgres (PGVector), Neo4j, Redis, LanceDB, ChromaDB, Qdrant, FAISS, Pinecone, Mongo Atlas Vector Search

**Supported Text Index Databases**: MongoDB, Postgres, SQLite  



**Optional**

- [Docker](https://docs.docker.com/get-docker/)
  
- To enable the OCR parsing capabilities, install [Tesseract v5.3.3](https://tesseract-ocr.github.io/tessdoc/Installation.html) and [Poppler v23.10.0](https://poppler.freedesktop.org/) native packages.




  **🚧 Change Log**

**Thursday, January 1 - v0.4.3 - WIP**  
 - Updated BaseModel and PromptCatalog classes 
 - Updated cloud model versions and support for OpenAI, Gemini and Anthropic latest models   
 - Removed deprecated model classes 
 - Removed deprecated modules (Dataset Builder and Graph)  
 - Work-in-Progress for other Model Class and Card updates  
 - Repo is up-to-date, but not in pip install release - targeted week of January 12, 2026  
   
**Monday, March 3 - v0.4.0**  
 - Updates in GGUF implementation, configs and libs  
 - Updates in ONNXRuntime implementation and configs  
 - New Models added to ModelCatalog, including phi-4, Deepseek-Qwen-7B, Deepseek-Qwen-14B, and many others  
 - Added support for Windows ARM64  
 - Changed default active_db to "sqlite" (both mongo and postgres available for production)  
 - Streamlined dependencies in core requirements.txt and pip install  
 - 'Extra/optional' dependencies available in requirements_extras.txt and through configurations passed in the pip install process (see setup.py for options)
   
**Friday, November 8 - v0.3.9**  
 - Enhanced Azure OpenAI configuration, including streaming generation  
 - Removed deprecated parser binaries for Linux aarch64 and Mac x86  
 - Added generator option for CustomTable insert rows to provide progress on larger table builds  
   
**Sunday, October 27 - v0.3.8**
 - Integrating Model Depot collection of 100+ OpenVino and ONNX Models into LLMWare default model catalog  
 - Supporting changes in model classes, model catalog and model configs  
   
**Sunday, October 6 - v0.3.7**  
- Added new model class - OVGenerativeModel - to support the use of models packaged in OpenVino format  
- Added new model class - ONNXGenerativeModel - to support use of models packaged in ONNX format  
- Getting started with [OpenVino example](https://github.com/llmware-ai/llmware/blob/main/solutions/openvino/using_openvino_models.py)  
- Getting started with [ONNX example](https://github.com/llmware-ai/llmware/blob/main/solutions/onnxruntime/using_onnx_models.py)  
  
**Tuesday, October 1 - v0.3.6**  
- Added new prompt and chat templates  
- Improved and updated model configurations    
- New utility functions for locating and highlighting text matches in search results  
- Improved hashing check utility functions  
  
**Monday, August 26 - v0.3.5**  
- Added 10 new BLING+SLIM models to Model Catalog - featuring Qwen2, Phi-3 and Phi-3.5  
- Launched new DRAGON models on Qwen-7B, Yi-9B, Mistral-v0.3, and Llama-3.1  
- Improved GGUF Configs to expand context window  
- Added model benchmark performance data to model configs 
- Enhanced Utilities hashing functions  

**Monday, July 29 - v03.4**  
- Enhanced safety protections for text2sql db reads for LLMfx agents   
- New examples - see [example](https://github.com/llmware-ai/llmware/blob/main/solutions/ui/dueling_chatbot.py)    
- More Notebook examples - see [notebook examples](https://github.com/llmware-ai/llmware/blob/main/tutorials/notebooks)      
  
**Monday, July 8 - v03.3**  
- Improvements in model configuration options, logging, and various small fixes  
- Improved Azure OpenAI configs - see [example](https://github.com/llmware-ai/llmware/blob/main/solutions/models/using-azure-openai.py)  
  
**Saturday, June 29 - v0.3.2**  
- Update to PDF and Office parsers - improvements to configurations in logging and text chunking options  
  
**Saturday, June 22 - v0.3.1**  
- Added module 3 to Fast Start example series [examples 7-9 on Agents & Function Calls](https://github.com/llmware-ai/llmware/tree/main/fast_start)  
- Added reranker Jina model for in-memory semantic similarity RAG - see [example](https://github.com/llmware-ai/llmware/tree/main/solutions/embeddings/using_semantic_reranker_with_rag.py)  
- Enhanced model fetching parameterization in model loading process  
- Added new 'tiny' versions of slim-extract and slim-summary in both Pytorch and GGUF versions - check out 'slim-extract-tiny-tool' and 'slim-summary-tiny-tool'  
- [Biz Bot] use case - see [example](https://github.com/llmware-ai/llmware/tree/main/solutions/use_cases/biz_bot.py) and [video](https://youtu.be/4nBYDEjxxTE?si=o6PDPbu0PVcT-tYd)  
- Updated numpy reqs <2 and updated yfinance version minimum (>=0.2.38)     

**Tuesday, June 4 - v0.3.0**  
- Added support for new Milvus Lite embedded 'no-install' database - see [example](https://github.com/llmware-ai/llmware/tree/main/solutions/embeddings/using_milvus_lite.py).   
- Added two new SLIM models to catalog and agent processes - ['q-gen'](https://github.com/llmware-ai/llmware/tree/main/solutions/slim_agents/using-slim-q-gen.py) and ['qa-gen'](https://github.com/llmware-ai/llmware/tree/main/solutions/slim_agents/using-slim-qa-gen.py)    
- Updated model class instantiation to provide more extensibility to add new classes in different modules  
- New welcome_to_llmware.sh and welcome_to_llmware_windows.sh fast install scripts  
- Enhanced Model class base with new configurable post_init and register methods  
- Created InferenceHistory to track global state of all inferences completed  
- Multiple improvements and updates to logging at module level  
- Note: starting with v0.3.0, pip install provides two options - a base minimal install `pip3 install llmware` which will support most use cases, and a larger install `pip3 install 'llmware[full]'` with other commonly-used libraries.  
  
**Wednesday, May 22 - v0.2.15**  
- Improvements in Model class handling of Pytorch and Transformers dependencies (just-in-time loading, if needed)  

**Saturday, May 18 - v0.2.14**  
- New OCR image parsing methods with [example](https://github.com/llmware-ai/llmware/tree/main/solutions/use_cases/slicing_and_dicing_office_docs.py)  
- Adding first part of logging improvements (WIP) in Configs and Models.    
- New embedding model added to catalog - industry-bert-loans.  
- Updates to model import methods and configurations.  

**Sunday, May 12 - v0.2.13**  
- New GGUF streaming method with [basic example](https://github.com/llmware-ai/llmware/tree/main/solutions/gguf/gguf_streaming.py) and [phi3 local chatbot](https://github.com/llmware-ai/llmware/tree/main/solutions/ui/gguf_streaming_chatbot.py)  
- Significant cleanups in ancillary imports and dependencies to reduce install complexity - note: the updated requirements.txt and setup.py files.  
- Defensive code to provide informative warning of any missing dependencies in specialized parts of the code, e.g., OCR, Web Parser.  
- Updates of tests, notice and documentation.   
- OpenAIConfigs created to support Azure OpenAI.   
  
**Sunday, May 5 - v0.2.12 Update**  
- Launched ["bling-phi-3"](https://huggingface.co/llmware/bling-phi-3) and ["bling-phi-3-gguf"](https://huggingface.co/llmware/bling-phi-3-gguf) in ModelCatalog - newest and most accurate BLING/DRAGON model  
- Added support for Python 3.12  
- Deprecated faiss and replaced with 'no-install' chromadb in Fast Start examples  
- Refactored Datasets, Graph and Web Services classes  
- Updated Voice parsing with WhisperCPP into Library  
  
**Monday, April 29 - v0.2.11 Update**  
- Updates to gguf libs for Phi-3 and Llama-3  
- Integrated WhisperCPP Model class and prebuilt shared libraries - [getting-started-example](https://github.com/llmware-ai/llmware/tree/main/solutions/gguf/using-whisper-cpp-getting-started.py)  
- New voice sample files for testing - [example](https://github.com/llmware-ai/llmware/tree/main/solutions/gguf/using-whisper-cpp-sample-files.py)  
- Improved CUDA detection on Windows and safety checks for older Mac OS versions  

**Monday, April 22 - v0.2.10 Update**  
- Updates to Agent class to support Natural Language queries of Custom Tables on Postgres [example](https://github.com/llmware-ai/llmware/tree/main/solutions/use_cases/agent_with_custom_tables.py)  
- New Agent API endpoint implemented with LLMWare Inference Server and new Agent capabilities [example](https://github.com/llmware-ai/llmware/tree/main/solutions/slim_agents/agent_api_endpoint.py)  
  
**Tuesday, April 16 - v0.2.9 Update**  
- New CustomTable class to rapidly create custom DB tables in conjunction with LLM-based workflows.  
- Enhanced methods for converting CSV and JSON/JSONL files into DB tables.  
- See new examples [Creating Custom Table example](https://github.com/llmware-ai/llmware/tree/main/solutions/sources/create_custom_table-1.py)
    
**Tuesday, April 9 - v0.2.8 Update**  
- Office Parser (Word Docx, Powerpoint PPTX, and Excel XLSX) - multiple improvements - new libs + Python method.  
- Includes: several fixes, improved text chunking controls, header text extraction and configuration options.  
- Generally, new office parser options conform with the new PDF parser options.  
- Please see [Office Parsing Configs example](https://github.com/llmware-ai/llmware/tree/main/solutions/sources/office_parser_new_configs.py)  

**Wednesday, April 3 - v0.2.7 Update**  
- PDF Parser - multiple improvements - new libs + Python methods.  
- Includes: UTF-8 encoding for European languages.  
- Includes: Better text chunking controls, header text extraction and configuration options.  
- Please see [PDF Parsing Configs example](https://github.com/llmware-ai/llmware/tree/main/solutions/sources/pdf_parser_new_configs.py) for more details.  
- Note:  deprecating support for aarch64-linux (will use 0.2.6 parsers).  Full support going forward for Linux Ubuntu20+ on x86_64 + with CUDA.  
  
**Friday, March 22 - v0.2.6 Update**  
- New SLIM models:  summary, extract, xsum, boolean, tags-3b, and combo sentiment-ner.  
- New logit and sampling analytics.  
- New SLIM examples showing how to use the new models.  
  
**Thursday, March 14 - v0.2.5 Update**  
- Improved support for GGUF on CUDA (Windows and Linux), with new prebuilt binaries and exception handling.  
- Enhanced model configuration options (sampling, temperature, top logit capture).  
- Added full back-level support for Ubuntu 20+ with parsers and GGUF engine.  
- Support for new Anthropic Claude 3 models.  
- New retrieval methods: document_lookup and aggregate_text.  
- New model:  bling-stablelm-3b-tool - fast, accurate 3b quantized question-answering model - one of our new favorites.  

**Wednesday, February 28 - v0.2.4 Update**  
- Major upgrade of GGUF Generative Model class - support for Stable-LM-3B, CUDA build options, and better control over sampling strategies.
- Note: new GGUF llama.cpp built libs packaged with build starting in v0.2.4.  
- Improved GPU support for HF Embedding Models.   
  
**Friday, February 16 - v0.2.3 Update**  
- Added 10+ embedding models to ModelCatalog - nomic, jina, bge, gte, ember and uae-large.   
- Updated OpenAI support >=1.0 and new text-3 embedding models.    
- SLIM model keys and output_values now accessible in ModelCatalog.  
- Updating encodings to 'utf-8-sig' to better handle txt/csv files with bom.  

**Latest Updates - 19 Jan 2024 - llmware v0.2.0**
  - Added new database integration options - Postgres and SQlite
  - Improved status update and parser event logging options for parallelized parsing
  - Significant enhancements to interactions between Embedding + Text collection databases
  - Improved error exception handling in loading dynamic modules

**Latest Updates - 15 Jan 2024: llmware v0.1.15**
  - Enhancements to dual pass retrieval queries
  - Expanded configuration objects and options for endpoint resources
    
**Latest Updates - 30 Dec 2023: llmware v0.1.14**
  - Added support for Open Chat inference servers (compatible with OpenAI API)
  - Improved capabilities for multiple embedding models and vector DB configurations
  - Added docker-compose install scripts for PGVector and Redis vector databases
  - Added 'bling-tiny-llama' to model catalog
         
**Latest Updates - 22 Dec 2023: llmware v0.1.13**
  - Added 3 new vector databases - Postgres (PG Vector), Redis, and Qdrant
  - Improved support for integrating sentence transformers directly in the model catalog
  - Improvements in the model catalog attributes
  - Multiple new Examples in Models & Embeddings, including GGUF, Vector database, and model catalog

- **17 Dec 2023: llmware v0.1.12**
  - dragon-deci-7b added to catalog - RAG-finetuned model on high-performance new 7B model base from Deci
  - New GGUFGenerativeModel class for easy integration of GGUF Models
  - Adding prebuilt llama_cpp / ctransformer shared libraries for Mac M1, Mac x86, Linux x86 and Windows
  - 3 DRAGON models packaged as Q4_K_M GGUF models for CPU laptop use (dragon-mistral-7b, dragon-llama-7b, dragon-yi-6b)
  - 4 leading open source chat models added to default catalog with Q4_K_M
  
- **8 Dec 2023: llmware v0.1.11**
  - New fast start examples for high volume Document Ingestion and Embeddings with Milvus.
  - New LLMWare 'Pop up' Inference Server model class and example script.
  - New Invoice Processing example for RAG.
  - Improved Windows stack management to support parsing larger documents.
  - Enhancing debugging log output mode options for PDF and Office parsers.

- **30 Nov 2023: llmware v0.1.10**
  - Windows added as a supported operating system.
  - Further enhancements to native code for stack management. 
  - Minor defect fixes.

- **24 Nov 2023: llmware v0.1.9**
  - Markdown (.md) files are now parsed and treated as text files.
  - PDF and Office parser stack optimizations which should avoid the need to set ulimit -s.
  - New llmware_models_fast_start.py example that allows discovery and selection of all llmware HuggingFace models.
  - Native dependencies (shared libraries and dependencies) now included in repo to faciliate local development.
  - Updates to the Status class to support PDF and Office document parsing status updates.
  - Minor defect fixes including image block handling in library exports.

- **17 Nov 2023: llmware v0.1.8**
  - Enhanced generation performance by allowing each model to specific the trailing space parameter.
  - Improved handling for eos_token_id for llama2 and mistral.
  - Improved support for Hugging Face dynamic loading
  - New examples with the new llmware DRAGON models.
    
- **14 Nov 2023: llmware v0.1.7**
  - Moved to Python Wheel package format for PyPi distribution to provide seamless installation of native dependencies on all supported platforms.  
  - ModelCatalog enhancements:
    - OpenAI update to include newly announced ‘turbo’ 4 and 3.5 models.
    - Cohere embedding v3 update to include new Cohere embedding models.
    - BLING models as out-of-the-box registered options in the catalog. They can be instantiated like any other model, even without the “hf=True” flag.
    - Ability to register new model names, within existing model classes, with the register method in ModelCatalog.
  - Prompt enhancements:
    - “evidence_metadata” added to prompt_main output dictionaries allowing prompt_main responses to be plug into the evidence and fact-checking steps without modification.
    - API key can now be passed directly in a prompt.load_model(model_name, api_key = “[my-api-key]”)
  - LLMWareInference Server - Initial delivery:
    - New Class for LLMWareModel which is a wrapper on a custom HF-style API-based model.    
    - LLMWareInferenceServer is a new class that can be instantiated on a remote (GPU) server to create a testing API-server that can be integrated into any Prompt workflow.    
 
- **03 Nov 2023: llmware v0.1.6**
  - Updated packaging to require mongo-c-driver 1.24.4 to temporarily workaround segmentation fault with mongo-c-driver 1.25.
  - Updates in python code needed in anticipation of future Windows support.  

- **27 Oct 2023: llmware v0.1.5**
  - Four new example scripts focused on RAG workflows with small, fine-tuned instruct models that run on a laptop (`llmware` [BLING](https://huggingface.co/llmware) models).
  - Expanded options for setting temperature inside a prompt class.
  - Improvement in post processing of Hugging Face model generation.
  - Streamlined loading of Hugging Face generative models into prompts.
  - Initial delivery of a central status class: read/write of embedding status with a consistent interface for callers.
  - Enhanced in-memory dictionary search support for multi-key queries.
  - Removed trailing space in human-bot wrapping to improve generation quality in some fine-tuned models.
  - Minor defect fixes, updated test scripts, and version update for Werkzeug to address [dependency security alert](https://github.com/llmware-ai/llmware/security/dependabot/2).
- **20 Oct 2023: llmware v0.1.4**
  - GPU support for Hugging Face models.
  - Defect fixes and additional test scripts.
- **13 Oct 2023: llmware v0.1.3**
  - MongoDB Atlas Vector Search support.
  - Support for authentication using a MongoDB connection string.
  - Document summarization methods.
  - Improvements in capturing the model context window automatically and passing changes in the expected output length.  
  - Dataset card and description with lookup by name.
  - Processing time added to model inference usage dictionary.
  - Additional test scripts, examples, and defect fixes.
- **06 Oct 2023: llmware v0.1.1**
  - Added test scripts to the github repository for regression testing.
  - Minor defect fixes and version update of Pillow to address [dependency security alert](https://github.com/llmware-ai/llmware/security/dependabot/1).
- **02 Oct 2023: llmware v0.1.0**  🔥 Initial release of llmware to open source!! 🔥




  [⬆️ Back to Top](#top)


## 🤓 Read our White Papers


- **Revolutionizing AI Deployment: Unleashing AI Acceleration with Intel's AI PCs and Model HQ by LLMWare** [AI PC Model HQ.pdf](https://github.com/user-attachments/files/18024139/AI.PC.Model.HQ.pdf)
- **Revultionizing AI Deployment (Intel Abstract Version)**  [LNL White paper (Abstract Version) final.pdf](https://github.com/user-attachments/files/18281644/LNL.White.paper.Abstract.Version.final.pdf)

- **Accelerating AI Powered Productivity with AI PCs** [Laptop.Performance.WP.Final (10).pdf](https://github.com/user-attachments/files/18024294/Laptop.Performance.WP.Final.10.pdf)

## Intel Joint Solutions

- **Arrow Lake** 
[IPA.Optimization.Summary.LLMWare (1).pdf](https://github.com/user-attachments/files/18292873/IPA.Optimization.Summary.LLMWare.1.pdf)

## About Model HQ
  - **Privacy Policy** [AI.BLOKS.PRIVACY.POLICY.1.3.25.pdf](https://github.com/user-attachments/files/19289355/AI.BLOKS.PRIVACY.POLICY.1.3.25.pdf)

- **Terms of Service** [AI.Bloks.Terms.of.Service.3.3.25.pdf](https://github.com/user-attachments/files/19289545/AI.Bloks.Terms.of.Service.3.3.25.pdf)

- **Acceptable Use Policy**[Acceptable Use Policy for Model HQ by AI BLOKS LLC.docx](https://github.com/user-attachments/files/18291481/Acceptable.Use.Policy.for.Model.HQ.by.AI.BLOKS.LLC.docx)

---

## File: docs/index.md

---
layout: default
title: Home | llmware
nav_order: 1
permalink: /
---
## Welcome to  

    <li class="d-inline-block mr-1">
        [](https://llmware.ai/)
    </li>
  

## 🧰🛠️🔩The Ultimate Toolkit for Enterprise RAG Pipelines with Small, Specialized Models   

From quickly building POCs to scalable LLM Apps for the enterprise, LLMWare is packed with all the tools you need. 

`llmware` is an integrated framework with over 50+ small, specialized, open source models for quickly developing LLM-based applications including Retrieval Augmented Generation (RAG) and Multi-Step Orchestration of Agent Workflows.  

This project provides a comprehensive set of tools that anyone can use - from a beginner to the most sophisticated AI developer - to rapidly build industrial-grade, knowledge-based enterprise LLM applications. 

Our specific focus is on making it easy to integrate open source small specialized models and connecting enterprise knowledge safely and securely. 


##  Getting Started 

1.  Install llmware - `pip3 install llmware`  


2.  Make sure that you are running on a [supported platform](https://www.github.com/llmware-ai/llmware/tree/main/docs/getting_started/platforms.md#platform-support).  


3.  Learn by example:  

    -- [Fast Start examples](https://www.github.com/llmware-ai/llmware/tree/main/fast_start) - structured set of 6 examples (with no DB installations required) to learn the main concepts of RAG with LLMWare - each example has extensive comments, and a supporting video on Youtube to walk you through it.    

    -- [Getting Started examples](https://www.github.com/llmware-ai/llmware/tree/main/examples/Getting_Started) - heavily-annotated examples that review many getting started elements - selecting a database, loading sample files, working with libraries, and how to use the Model Catalog.  

    -- [Use Case examples](https://www.github.com/llmware-ai/llmware/tree/main/examples/Use_Cases) - longer examples that integrate several components of LLMWare to provide a framework for a solution for common use case patterns.  

    -- Dive into specific area of interest - [Parsing](https://www.github.com/llmware-ai/llmware/tree/main/examples/Parsing) - [Models](https://www.github.com/llmware-ai/llmware/tree/main/examples/Models) - [Prompts](https://www.github.com/llmware-ai/llmware/tree/main/examples/Models) - [Agents](https://www.github.com/llmware-ai/llmware/tree/main/examples/SLIM-Agents)  - and many more ...


4.  We provide extensive [sample files](https://www.github.com/llmware-ai/tree/main/examples/Getting_Started/loading_sample_files.py) integrated into the examples, so you can copy-paste-run, and quickly validate that the installation is set up correctly, and to start seeing key classes and methods in action.  We would encourage you to start with the 'out of the box' example first, and then use the example as the launching point for inserting your documents, models, queries, and workflows.  


5.  Learn by watching: check out the [LLMWare Youtube channel](https://www.youtube.com/@llmware).  


6.  Share with the community:  join us on [Discord](https://discord.gg/MhZn5Nc39h).  


[Install llmware](#install-llmware){: .btn .btn-primary .fs-5 .mb-4 .mb-md-0 .mr-2 }  
[Common Setup & Configuration Items](#platform-support){: .btn .fs-5 .mb-4 .mb-md-0 }  
[Architecture](architecture.md/#llmware-architecture){: .btn .fs-5 .mb-4 .mb-md-0 }  
[View llmware on GitHub](https://www.github.com/llmware-ai/llmware/tree/main){: .btn .fs-5 .mb-4 .mb-md-0 }  
[Open an Issue on GitHub](https://www.github.com/llmware-ai/llmware/issues){: .btn .fs-5 .mb-4 .mb-md-0 }  



# Install llmware 

___  
**Using Pip Install**  

- Installing llmware is easy:  `pip3 install llmware` 


- If you prefer, we also provide a set of recent wheels in the [wheel archives](https://www.github.com/llmware-ai/llmware/tree/main/wheel_archives) in this repository, which can be downloaded individually and used as follows:  

```bash
pip3 install llmware-0.2.12-py3-none-any.wheel
````  

- We generally keep the main branch of this repository current with all changes, but we only publish new wheels to PyPi approximately once per week  

___

___
**Cloning the Repository**  

- If you prefer to clone the repository:  

```bash
git clone git@github.com:llmware-ai/llmware.git
```

- The llmware package is contained entirely in the /llmware folder path, so you should be able to drop this folder (with all of its contents) into a project tree, and use the llmware module essentially the same as a pip install.  

- Please ensure that you are capturing and updating the /llmware/lib folder, which includes required compiled shared libraries.  If you prefer, you can keep only those libs required for your OS platform.  

- After cloning the repo, we provide a short 'welcome to llmware' automation script, which can be used to install the projects requirements (from llmware/requirements.txt), install several optional dependencies that are commonly used in examples, copy several good 'getting started' examples into the root folder, and then run a 'welcome_example.py' script to get started using our models.  To use the "welcome to llmware" script:  

Windows:  
```bash
.\welcome_to_llmware_windows.sh
```

Mac/Linux:
```bash
sh ./welcome_to_llmware.sh
```

# More information about the project - [see main repository](https://www.github.com/llmware-ai/llmware.git)


# About the project

`llmware` is &copy; 2023-{{ "now" | date: "%Y" }} by [AI Bloks](https://www.aibloks.com/home).

## Contributing
Please first discuss any change you want to make publicly, for example on GitHub via raising an [issue](https://github.com/llmware-ai/llmware/issues) or starting a [new discussion](https://github.com/llmware-ai/llmware/discussions).
You can also write an email or start a discussion on our Discrod channel.
Read more about becoming a contributor in the [GitHub repo](https://github.com/llmware-ai/llmware/blob/main/CONTRIBUTING.md).

## Code of conduct
We welcome everyone into the ``llmware`` community.
[View our Code of Conduct](https://github.com/llmware-ai/llmware/blob/main/CODE_OF_CONDUCT.md) in our GitHub repository.

## ``llmware`` and [AI Bloks](https://www.aibloks.com/home)
``llmware`` is an open source project from [AI Bloks](https://www.aibloks.com/home) - the company behind ``llmware``.
The company offers a Software as a Service (SaaS) Retrieval Augmented Generation (RAG) service.
[AI Bloks](https://www.aibloks.com/home) was founded by [Namee Oberst](https://www.linkedin.com/in/nameeoberst/) and [Darren Oberst](https://www.linkedin.com/in/darren-oberst-34a4b54/) in October 2022.

## License

`llmware` is distributed by an [Apache-2.0 license](https://www.github.com/llmware-ai/llmware/blob/main/LICENSE).

## Thank you to the contributors of ``llmware``!

{% for contributor in site.github.contributors %}
  <li class="d-inline-block mr-1">
     <a href="{{ contributor.html_url }}">
        
    </a>
  </li>
{% endfor %}



---

    <li class="d-inline-block mr-1">
        [](https://discord.gg/MhZn5Nc39h)
    </li>
    <li class="d-inline-block mr-1">
        [](https://www.youtube.com/@llmware)
    </li>
    <li class="d-inline-block mr-1">
        [](https://huggingface.co/llmware)
    </li>
    <li class="d-inline-block mr-1">
        [](https://www.linkedin.com/company/aibloks/)
    </li>
    <li class="d-inline-block mr-1">
        [](https://twitter.com/AiBloks)
    </li>
    <li class="d-inline-block mr-1">
        [](https://www.instagram.com/aibloks/)
    </li>

---