'
28 | ```
29 |
30 | 3. Install the required dependencies:
31 | ```bash
32 | pip install -r requirements.lock
33 | ```
34 |
35 | ---
36 |
37 | ## Running the Application
38 |
39 | 1. Start the Flask server:
40 | ```bash
41 | python app.py
42 | ```
43 |
44 | 2. Open your web browser and navigate to the URL displayed in the terminal (default: `http://localhost:5000`).
45 |
46 | ---
47 |
48 | ## Using the Chatbot
49 |
50 | ### File Upload
51 |
52 | 1. On the interface, upload a `.txt` file.
53 | 2. Ensure the file format is supported and its size is manageable.
54 | 3. The file will be processed, and a "brain" instance will be created.
55 |
56 | ### Asking Questions
57 |
58 | 1. Use the microphone to record your question (audio upload).
59 | 2. The chatbot will process your question and respond with an audio answer.
60 |
61 | ---
62 |
63 | ## How It Works
64 |
65 | ### File Upload
66 | - Users upload a `.txt` file.
67 | - The file is saved to the `uploads` directory and used to create a "brain" using **Quivr**.
68 |
69 | ### Session Management
70 | - Each session is associated with a unique ID, allowing the system to cache the user's "brain."
71 |
72 | ### Speech-to-Text
73 | - User audio files are processed with OpenAI's **Whisper** model to generate transcripts.
74 |
75 | ### Question Answering
76 | - The "brain" processes the transcribed text, retrieves relevant answers, and generates a response.
77 |
78 | ### Text-to-Speech
79 | - The answer is converted to audio using OpenAI's text-to-speech model and returned to the user.
80 |
81 | ---
82 |
83 | ## Workflow
84 |
85 | 1. **Upload File**:
86 | - The user uploads a `.txt` file.
87 | - A "brain" is created and cached for the session.
88 |
89 | 2. **Ask Questions**:
90 | - The user uploads an audio file containing a question.
91 | - The question is transcribed, processed, and answered using the "brain."
92 |
93 | 3. **Answer Delivery**:
94 | - The answer is converted to audio and returned to the user as a Base64-encoded string.
95 |
96 | ---
97 |
98 | ## Features
99 |
100 | 1. **File Upload and Processing**:
101 | - Creates a context-aware "brain" from the uploaded text file.
102 |
103 | 2. **Audio-based Interaction**:
104 | - Supports speech-to-text for input and text-to-speech for responses.
105 |
106 | 3. **Session Management**:
107 | - Retains user context throughout the interaction.
108 |
109 | 4. **Integration with OpenAI**:
110 | - Uses OpenAI models for transcription, answer generation, and audio synthesis.
111 |
112 | ---
113 |
114 | Enjoy interacting with your text files through an intuitive voice-based interface!
--------------------------------------------------------------------------------
/docs/docs/examples/custom_storage.md:
--------------------------------------------------------------------------------
1 | # Transparent Storage
2 |
3 | **todo**
4 |
--------------------------------------------------------------------------------
/docs/docs/examples/index.md:
--------------------------------------------------------------------------------
1 | # Examples
--------------------------------------------------------------------------------
/docs/docs/index.md:
--------------------------------------------------------------------------------
1 | # Welcome to Quivr Documentation
2 |
3 | Quivr, helps you build your second brain, utilizes the power of GenerativeAI to be your personal assistant !
4 |
5 | ## Key Features 🎯
6 |
7 | - **Opiniated RAG**: We created a RAG that is opinionated, fast and efficient so you can focus on your product
8 | - **LLMs**: Quivr works with any LLM, you can use it with OpenAI, Anthropic, Mistral, Gemma, etc.
9 | - **Any File**: Quivr works with any file, you can use it with PDF, TXT, Markdown, etc and even add your own parsers.
10 | - **Customize your RAG**: Quivr allows you to customize your RAG, add internet search, add tools, etc.
11 | - **Integrations with Megaparse**: Quivr works with [Megaparse](https://github.com/quivrhq/megaparse), so you can ingest your files with Megaparse and use the RAG with Quivr.
12 |
13 | >We take care of the RAG so you can focus on your product. Simply install quivr-core and add it to your project. You can now ingest your files and ask questions.*
14 |
15 | **We will be improving the RAG and adding more features everything, stay tuned!**
16 |
17 |
18 | This is the core of Quivr, the brain of Quivr.com.
19 |
20 |
23 |
24 | ## Getting Started 🚀
25 |
26 | You can find everything on the [documentation](https://core.quivr.app/).
27 |
28 | ### Prerequisites 📋
29 |
30 | Ensure you have the following installed:
31 |
32 | - Python 3.10 or newer
33 |
34 | ### 30 seconds Installation 💽
35 |
36 |
37 | - **Step 1**: Install the package
38 |
39 |
40 |
41 | ```bash
42 | pip install quivr-core # Check that the installation worked
43 | ```
44 |
45 |
46 | - **Step 2**: Create a RAG with 5 lines of code
47 |
48 | ```python
49 | import tempfile
50 |
51 | from quivr_core import Brain
52 |
53 | if __name__ == "__main__":
54 | with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
55 | temp_file.write("Gold is a liquid of blue-like colour.")
56 | temp_file.flush()
57 |
58 | brain = Brain.from_files(
59 | name="test_brain",
60 | file_paths=[temp_file.name],
61 | )
62 |
63 | answer = brain.ask(
64 | "what is gold? asnwer in french"
65 | )
66 | print("answer:", answer)
67 | ```
68 |
69 |
--------------------------------------------------------------------------------
/docs/docs/parsers/index.md:
--------------------------------------------------------------------------------
1 | # Parsers
2 |
3 | Quivr provides a suite of parsers to extract structured data from various sources.
4 |
--------------------------------------------------------------------------------
/docs/docs/parsers/megaparse.md:
--------------------------------------------------------------------------------
1 | ## Megaparse
2 |
3 | ::: quivr_core.processor.implementations.megaparse_processor
4 | options:
5 | heading_level: 2
--------------------------------------------------------------------------------
/docs/docs/parsers/simple.md:
--------------------------------------------------------------------------------
1 | ## Simple Txt
2 |
3 | ::: quivr_core.processor.implementations.simple_txt_processor
4 | options:
5 | heading_level: 2
--------------------------------------------------------------------------------
/docs/docs/quickstart.md:
--------------------------------------------------------------------------------
1 | # Quick start
2 |
3 | If you need to quickly start talking to your list of files, here are the steps.
4 |
5 | 1. Add your API Keys to your environment variables
6 | ```python
7 | import os
8 | os.environ["OPENAI_API_KEY"] = "myopenai_apikey"
9 |
10 | ```
11 | Check our `.env.example` file to see the possible environment variables you can configure. Quivr supports APIs from Anthropic, OpenAI, and Mistral. It also supports local models using Ollama.
12 |
13 | 2. Create a Brain with Quivr default configuration
14 | ```python
15 | from quivr_core import Brain
16 |
17 | brain = Brain.from_files(name = "my smart brain",
18 | file_paths = ["/my_smart_doc.pdf", "/my_intelligent_doc.txt"],
19 | )
20 |
21 | ```
22 |
23 | 3. Launch a Chat
24 | ```python
25 | brain.print_info()
26 |
27 | from rich.console import Console
28 | from rich.panel import Panel
29 | from rich.prompt import Prompt
30 |
31 | console = Console()
32 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
33 |
34 | while True:
35 | # Get user input
36 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
37 |
38 | # Check if user wants to exit
39 | if question.lower() == "exit":
40 | console.print(Panel("Goodbye!", style="bold yellow"))
41 | break
42 |
43 | answer = brain.ask(question)
44 | # Print the answer with typing effect
45 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
46 |
47 | console.print("-" * console.width)
48 |
49 | brain.print_info()
50 | ```
51 |
52 | And now you are all set up to talk with your brain !
53 |
54 | ## Custom Brain
55 | If you want to change the language or embeddings model, you can modify the parameters of the brain.
56 |
57 | Let's say you want to use a LLM from Mistral and a specific embedding model :
58 | ```python
59 | from quivr_core import Brain
60 | from langchain_core.embeddings import Embeddings
61 |
62 | brain = Brain.from_files(name = "my smart brain",
63 | file_paths = ["/my_smart_doc.pdf", "/my_intelligent_doc.txt"],
64 | llm=LLMEndpoint(
65 | llm_config=LLMEndpointConfig(model="mistral-small-latest", llm_base_url="https://api.mistral.ai/v1/chat/completions"),
66 | ),
67 | embedder=Embeddings(size=64),
68 | )
69 | ```
70 |
71 | Note : [Embeddings](https://python.langchain.com/docs/integrations/text_embedding/) is a langchain class that lets you chose from a large variety of embedding models. Please check out the following docs to know the panel of models you can try.
72 |
73 | ## Launch with Chainlit
74 |
75 | If you want to quickly launch an interface with streamlit, you can simply do at the root of the project :
76 | ```bash
77 | cd examples/chatbot /
78 | rye sync /
79 | rye run chainlit run chainlit.py
80 | ```
81 | For more detail, go in [examples/chatbot/chainlit.md](https://github.com/QuivrHQ/quivr/tree/main/examples/chatbot)
82 |
83 | Note : Modify the Brain configs directly in examples/chatbot/main.py;
84 |
--------------------------------------------------------------------------------
/docs/docs/storage/base.md:
--------------------------------------------------------------------------------
1 | # StorageBase
2 |
3 | ::: quivr_core.storage.storage_base
4 | options:
5 | heading_level: 2
6 |
--------------------------------------------------------------------------------
/docs/docs/storage/index.md:
--------------------------------------------------------------------------------
1 | # 🗄️ Storage
2 |
3 | ## Your Brain’s File Management System
4 |
5 | The `Storage` class is the backbone of how a brain interacts with files in `quivr-core`. Every brain holds a reference to an underlying storage system to manage its files. All storages should implement the `StorageBase` base classe that provides the structure and methods to make that happen seamlessly. Let's walk through how it works:
6 |
7 | - **Brain-Storage Connection:** Your brain holds a reference to a storage system. This class is the main way your brain can interact with and manage the files it uses. Adding files to a brain will upload them to the storage. This means that files in the storage are stored **before** processing!
8 | - **File Management:** the storage holds a set of `QuivrFile` objects, which are the building blocks of your brain’s file system. The storage can store them remotely or locally or hold simple
9 |
10 | ### What can you do with this storage system?
11 |
12 | 1. Upload Files: You can add new files to your storage whenever you need. The system also lets you decide whether to overwrite existing files or not.
13 | 2. Get Files: Need to see what's in your storage? No problem. You can easily retrieve a list of all the files that are stored.
14 | 3. Delete Files: Clean-up is simple. You can remove any file from your storage by referencing its unique file ID (more on that in `QuivrFile`).
15 |
16 | StorageBase is the foundation of how your brain organizes, uploads, retrieves, and deletes its files. It ensures that your brain can always stay up-to-date with the files it needs, making file management smooth and intuitive. You can build your own storage system by subclassing the `StorageBase` class and passing it to the brain. See [custom_storage](../examples/custom_storage.md) for more details.
17 |
18 | ### Storage Implementations in `quivr_core`
19 |
20 | `quivr_core` currently offers two storage implementations: `LocalStorage` and `TransparentStorage`:
21 |
22 | - **LocalStorage**:
23 | This storage type is perfect when you want to keep files on your local machine. `LocalStorage` saves your files to a specific directory, either a default path (`~/.cache/quivr/files`) or a user-defined location. It can store files by copying them or by creating symbolic links to the original files, based on your preference. This storage type also keeps track of file hashes to prevent accidental overwrites during uploads.
24 |
25 | - **TransparentStorage**:
26 | The `TransparentStorage` implementation offers a lightweight and flexible approach, mainly managing files in memory without a need for local file paths. This storage system is useful when you don't need persistent storage but rather an easy way to store and retrieve files temporarily during the brain's operation.
27 |
28 | Each of these storage systems has its own strengths, catering to different use cases. As `quivr_core` evolves, we will implementat more ande more storage systems allowing for even more advanced and customized ways to manage your files like `S3Storage`, `NFSStorage` ...
29 |
--------------------------------------------------------------------------------
/docs/docs/storage/local_storage.md:
--------------------------------------------------------------------------------
1 | # LocalStorage
2 |
3 | ::: quivr_core.storage.local_storage
4 | options:
5 | heading_level: 2
6 |
--------------------------------------------------------------------------------
/docs/docs/vectorstores/faiss.md:
--------------------------------------------------------------------------------
1 | # Faiss
--------------------------------------------------------------------------------
/docs/docs/vectorstores/index.md:
--------------------------------------------------------------------------------
1 | # Vector Stores
2 |
3 |
--------------------------------------------------------------------------------
/docs/docs/vectorstores/pgvector.md:
--------------------------------------------------------------------------------
1 | # PGVector
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/basic_ingestion.excalidraw.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/docs/docs/workflows/examples/basic_ingestion.excalidraw.png
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/basic_ingestion.md:
--------------------------------------------------------------------------------
1 | # Basic ingestion
2 |
3 | 
4 |
5 |
6 | Creating a basic ingestion workflow like the one above is simple, here are the steps:
7 |
8 | 1. Add your API Keys to your environment variables
9 | ```python
10 | import os
11 | os.environ["OPENAI_API_KEY"] = "myopenai_apikey"
12 |
13 | ```
14 | Check our `.env.example` file to see the possible environment variables you can configure. Quivr supports APIs from Anthropic, OpenAI, and Mistral. It also supports local models using Ollama.
15 |
16 | 2. Create the YAML file ``basic_ingestion_workflow.yaml`` and copy the following content in it
17 | ```yaml
18 | parser_config:
19 | megaparse_config:
20 | strategy: "auto" # for unstructured, it can be "auto", "fast", "hi_res", "ocr_only", see https://docs.unstructured.io/open-source/concepts/partitioning-strategies#partitioning-strategies
21 | pdf_parser: "unstructured"
22 | splitter_config:
23 | chunk_size: 400 # in tokens
24 | chunk_overlap: 100 # in tokens
25 | ```
26 |
27 | 3. Create a Brain using the above configuration and the list of files you want to ingest
28 | ```python
29 | from quivr_core import Brain
30 | from quivr_core.config import IngestionConfig
31 |
32 | config_file_name = "./basic_ingestion_workflow.yaml"
33 |
34 | ingestion_config = IngestionConfig.from_yaml(config_file_name)
35 |
36 | processor_kwargs = {
37 | "megaparse_config": ingestion_config.parser_config.megaparse_config,
38 | "splitter_config": ingestion_config.parser_config.splitter_config,
39 | }
40 |
41 | brain = Brain.from_files(name = "my smart brain",
42 | file_paths = ["./my_first_doc.pdf", "./my_second_doc.txt"],
43 | processor_kwargs=processor_kwargs,
44 | )
45 |
46 | ```
47 |
48 | 4. Launch a Chat
49 | ```python
50 | brain.print_info()
51 |
52 | from rich.console import Console
53 | from rich.panel import Panel
54 | from rich.prompt import Prompt
55 |
56 | console = Console()
57 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
58 |
59 | while True:
60 | # Get user input
61 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
62 |
63 | # Check if user wants to exit
64 | if question.lower() == "exit":
65 | console.print(Panel("Goodbye!", style="bold yellow"))
66 | break
67 |
68 | answer = brain.ask(question)
69 | # Print the answer with typing effect
70 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
71 |
72 | console.print("-" * console.width)
73 |
74 | brain.print_info()
75 | ```
76 |
77 | 5. You are now all set up to talk with your brain and test different chunking strategies by simply changing the configuration file!
78 |
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/basic_rag.excalidraw.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/docs/docs/workflows/examples/basic_rag.excalidraw.png
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/basic_rag.md:
--------------------------------------------------------------------------------
1 | # Basic RAG
2 |
3 | 
4 |
5 |
6 | Creating a basic RAG workflow like the one above is simple, here are the steps:
7 |
8 |
9 | 1. Add your API Keys to your environment variables
10 | ```python
11 | import os
12 | os.environ["OPENAI_API_KEY"] = "myopenai_apikey"
13 |
14 | ```
15 | Check our `.env.example` file to see the possible environment variables you can configure. Quivr supports APIs from Anthropic, OpenAI, and Mistral. It also supports local models using Ollama.
16 |
17 | 2. Create the YAML file ``basic_rag_workflow.yaml`` and copy the following content in it
18 | ```yaml
19 | workflow_config:
20 | name: "standard RAG"
21 | nodes:
22 | - name: "START"
23 | edges: ["filter_history"]
24 |
25 | - name: "filter_history"
26 | edges: ["rewrite"]
27 |
28 | - name: "rewrite"
29 | edges: ["retrieve"]
30 |
31 | - name: "retrieve"
32 | edges: ["generate_rag"]
33 |
34 | - name: "generate_rag" # the name of the last node, from which we want to stream the answer to the user
35 | edges: ["END"]
36 |
37 | # Maximum number of previous conversation iterations
38 | # to include in the context of the answer
39 | max_history: 10
40 |
41 | # Reranker configuration
42 | reranker_config:
43 | # The reranker supplier to use
44 | supplier: "cohere"
45 |
46 | # The model to use for the reranker for the given supplier
47 | model: "rerank-multilingual-v3.0"
48 |
49 | # Number of chunks returned by the reranker
50 | top_n: 5
51 |
52 | # Configuration for the LLM
53 | llm_config:
54 |
55 | # maximum number of tokens passed to the LLM to generate the answer
56 | max_input_tokens: 4000
57 |
58 | # temperature for the LLM
59 | temperature: 0.7
60 | ```
61 |
62 | 3. Create a Brain with the default configuration
63 | ```python
64 | from quivr_core import Brain
65 |
66 | brain = Brain.from_files(name = "my smart brain",
67 | file_paths = ["./my_first_doc.pdf", "./my_second_doc.txt"],
68 | )
69 |
70 | ```
71 |
72 | 4. Launch a Chat
73 | ```python
74 | brain.print_info()
75 |
76 | from rich.console import Console
77 | from rich.panel import Panel
78 | from rich.prompt import Prompt
79 | from quivr_core.config import RetrievalConfig
80 |
81 | config_file_name = "./basic_rag_workflow.yaml"
82 |
83 | retrieval_config = RetrievalConfig.from_yaml(config_file_name)
84 |
85 | console = Console()
86 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
87 |
88 | while True:
89 | # Get user input
90 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
91 |
92 | # Check if user wants to exit
93 | if question.lower() == "exit":
94 | console.print(Panel("Goodbye!", style="bold yellow"))
95 | break
96 |
97 | answer = brain.ask(question, retrieval_config=retrieval_config)
98 | # Print the answer with typing effect
99 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
100 |
101 | console.print("-" * console.width)
102 |
103 | brain.print_info()
104 | ```
105 |
106 | 5. You are now all set up to talk with your brain and test different retrieval strategies by simply changing the configuration file!
107 |
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/rag_with_web_search.excalidraw.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/docs/docs/workflows/examples/rag_with_web_search.excalidraw.png
--------------------------------------------------------------------------------
/docs/docs/workflows/examples/rag_with_web_search.md:
--------------------------------------------------------------------------------
1 | # RAG with web search
2 |
3 |
4 | 
5 |
6 | Follow the instructions below to create the agentic RAG workflow shown above, which includes some advanced capabilities such as:
7 |
8 | * **user intention detection** - the agent can detect if the user wants to activate the web search tool to look for information not present in the documents;
9 | * **dynamic chunk retrieval** - the number of retrieved chunks is not fixed, but determined dynamically using the reranker's relevance scores and the user-provided ``relevance_score_threshold``;
10 | * **web search** - the agent can search the web for more information if needed.
11 |
12 |
13 | ---
14 |
15 | 1. Add your API Keys to your environment variables
16 | ```python
17 | import os
18 | os.environ["OPENAI_API_KEY"] = "my_openai_api_key"
19 | os.environ["TAVILY_API_KEY"] = "my_tavily_api_key"
20 |
21 | ```
22 | Check our `.env.example` file to see the possible environment variables you can configure. Quivr supports APIs from Anthropic, OpenAI, and Mistral. It also supports local models using Ollama.
23 |
24 | 2. Create the YAML file ``rag_with_web_search_workflow.yaml`` and copy the following content in it
25 | ```yaml
26 | workflow_config:
27 | name: "RAG with web search"
28 |
29 | # List of tools that the agent can activate if the user instructions require it
30 | available_tools:
31 | - "web search"
32 |
33 | nodes:
34 | - name: "START"
35 | conditional_edge:
36 | routing_function: "routing_split"
37 | conditions: ["edit_system_prompt", "filter_history"]
38 |
39 | - name: "edit_system_prompt"
40 | edges: ["filter_history"]
41 |
42 | - name: "filter_history"
43 | edges: ["dynamic_retrieve"]
44 |
45 | - name: "dynamic_retrieve"
46 | conditional_edge:
47 | routing_function: "tool_routing"
48 | conditions: ["run_tool", "generate_rag"]
49 |
50 | - name: "run_tool"
51 | edges: ["generate_rag"]
52 |
53 | - name: "generate_rag" # the name of the last node, from which we want to stream the answer to the user
54 | edges: ["END"]
55 | tools:
56 | - name: "cited_answer"
57 |
58 | # Maximum number of previous conversation iterations
59 | # to include in the context of the answer
60 | max_history: 10
61 |
62 | # Number of chunks returned by the retriever
63 | k: 40
64 |
65 | # Reranker configuration
66 | reranker_config:
67 | # The reranker supplier to use
68 | supplier: "cohere"
69 |
70 | # The model to use for the reranker for the given supplier
71 | model: "rerank-multilingual-v3.0"
72 |
73 | # Number of chunks returned by the reranker
74 | top_n: 5
75 |
76 | # Among the chunks returned by the reranker, only those with relevance
77 | # scores equal or above the relevance_score_threshold will be returned
78 | # to the LLM to generate the answer (allowed values are between 0 and 1,
79 | # a value of 0.1 works well with the cohere and jina rerankers)
80 | relevance_score_threshold: 0.01
81 |
82 | # LLM configuration
83 | llm_config:
84 |
85 | # maximum number of tokens passed to the LLM to generate the answer
86 | max_input_tokens: 8000
87 |
88 | # temperature for the LLM
89 | temperature: 0.7
90 | ```
91 |
92 | 3. Create a Brain with the default configuration
93 | ```python
94 | from quivr_core import Brain
95 |
96 | brain = Brain.from_files(name = "my smart brain",
97 | file_paths = ["./my_first_doc.pdf", "./my_second_doc.txt"],
98 | )
99 |
100 | ```
101 |
102 | 4. Launch a Chat
103 | ```python
104 | brain.print_info()
105 |
106 | from rich.console import Console
107 | from rich.panel import Panel
108 | from rich.prompt import Prompt
109 | from quivr_core.config import RetrievalConfig
110 |
111 | config_file_name = "./rag_with_web_search_workflow.yaml"
112 |
113 | retrieval_config = RetrievalConfig.from_yaml(config_file_name)
114 |
115 | console = Console()
116 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
117 |
118 | while True:
119 | # Get user input
120 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
121 |
122 | # Check if user wants to exit
123 | if question.lower() == "exit":
124 | console.print(Panel("Goodbye!", style="bold yellow"))
125 | break
126 |
127 | answer = brain.ask(question, retrieval_config=retrieval_config)
128 | # Print the answer with typing effect
129 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
130 |
131 | console.print("-" * console.width)
132 |
133 | brain.print_info()
134 | ```
135 |
136 | 5. You are now all set up to talk with your brain and test different retrieval strategies by simply changing the configuration file!
137 |
--------------------------------------------------------------------------------
/docs/docs/workflows/index.md:
--------------------------------------------------------------------------------
1 | # Workflows
2 |
3 | In this section, you will find examples of workflows that you can use to create your own agentic RAG systems.
4 |
--------------------------------------------------------------------------------
/docs/mkdocs.yml:
--------------------------------------------------------------------------------
1 | site_name: Quivr
2 | extra_css:
3 | - css/style.css
4 |
5 | markdown_extensions:
6 | - attr_list
7 | - admonition
8 | - pymdownx.details
9 | - pymdownx.superfences
10 | - md_in_html
11 | - toc:
12 | permalink: "#"
13 |
14 | theme:
15 | custom_dir: overrides
16 | features:
17 | - navigation.instant
18 | - navigation.tabs
19 | - navigation.indexes
20 | - navigation.top
21 | - navigation.footer
22 | - toc.follow
23 | - content.code.copy
24 | - search.suggest
25 | - search.highlight
26 | name: material
27 | palette:
28 | - media: (prefers-color-scheme)
29 | toggle:
30 | icon: material/brightness-auto
31 | name: Switch to light mode
32 | - accent: purple
33 | media: "(prefers-color-scheme: light)"
34 | primary: white
35 | scheme: default
36 | toggle:
37 | icon: material/brightness-7
38 | name: Switch to dark mode
39 | - accent: purple
40 | media: "(prefers-color-scheme: dark)"
41 | primary: black
42 | scheme: slate
43 | toggle:
44 | icon: material/brightness-4
45 | name: Switch to system preference
46 |
47 | plugins:
48 | - search
49 | - mkdocstrings:
50 | default_handler: python
51 | handlers:
52 | python:
53 | docstring_style: google
54 | options:
55 | show_source: false
56 | heading_level: 2
57 | separate_signature: true
58 |
59 | nav:
60 | - Home:
61 | - index.md
62 | - quickstart.md
63 | - Brain:
64 | - brain/index.md
65 | - brain/brain.md
66 | - brain/chat.md
67 | - Storage:
68 | - storage/index.md
69 | - storage/base.md
70 | - storage/local_storage.md
71 | - Parsers:
72 | - parsers/index.md
73 | - parsers/megaparse.md
74 | - parsers/simple.md
75 | - Vector Stores:
76 | - vectorstores/index.md
77 | - vectorstores/faiss.md
78 | - vectorstores/pgvector.md
79 | - Workflows:
80 | - workflows/index.md
81 | - Examples:
82 | - workflows/examples/basic_ingestion.md
83 | - workflows/examples/basic_rag.md
84 | - workflows/examples/rag_with_web_search.md
85 | - Configuration:
86 | - config/index.md
87 | - config/config.md
88 | - config/base_config.md
89 | - Examples:
90 | - examples/index.md
91 | - examples/custom_storage.md
92 | - examples/chatbot.md
93 | - examples/chatbot_voice.md
94 | - examples/chatbot_voice_flask.md
95 | - Enterprise: https://docs.quivr.app/
96 |
--------------------------------------------------------------------------------
/docs/overrides/empty:
--------------------------------------------------------------------------------
1 | empty
--------------------------------------------------------------------------------
/docs/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "docs"
3 | version = "0.1.0"
4 | description = "Add your description here"
5 | authors = [
6 | { name = "Stan Girard", email = "stan@quivr.app" }
7 | ]
8 | dependencies = [
9 | "quivr-core @ file:///${PROJECT_ROOT}/../core",
10 | "mkdocs>=1.6.1",
11 | "mkdocstrings[python]>=0.26.0",
12 | "mkdocs-jupyter>=0.24.8",
13 | "mkdocs-include-dir-to-nav>=1.2.0",
14 | "mkdocs-material>=9.5.34",
15 | "mkdocs-redirects>=1.2.1",
16 | ]
17 | readme = "README.md"
18 | requires-python = ">= 3.8"
19 |
20 | [build-system]
21 | requires = ["hatchling"]
22 | build-backend = "hatchling.build"
23 |
24 | [tool.rye]
25 | managed = true
26 | dev-dependencies = []
27 | virtual = true
28 |
29 | [tool.rye.scripts]
30 | docs = "mkdocs serve"
31 | build_docs = "mkdocs build --strict"
32 |
33 | [tool.basedpyright]
34 | include = ["src/"]
35 | # Ensure that it uses the .venv that we created for this project with the lockfile
36 | venvPath="./"
37 | venv=".venv"
38 | # We really only care about some import issues, so we disable everything and report on missing imports:
39 | typeCheckingMode = "off"
40 | reportMissingImports = true
41 |
42 |
43 | [tool.hatch.metadata]
44 | allow-direct-references = true
45 |
--------------------------------------------------------------------------------
/docs/src/docs/__init__.py:
--------------------------------------------------------------------------------
1 | def hello() -> str:
2 | return "Hello from docs!"
3 |
--------------------------------------------------------------------------------
/examples/chatbot/.chainlit/config.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | # Whether to enable telemetry (default: true). No personal data is collected.
3 | enable_telemetry = true
4 |
5 |
6 | # List of environment variables to be provided by each user to use the app.
7 | user_env = []
8 |
9 | # Duration (in seconds) during which the session is saved when the connection is lost
10 | session_timeout = 3600
11 |
12 | # Enable third parties caching (e.g LangChain cache)
13 | cache = false
14 |
15 | # Authorized origins
16 | allow_origins = ["*"]
17 |
18 | # Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
19 | # follow_symlink = false
20 |
21 | [features]
22 | # Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
23 | unsafe_allow_html = false
24 |
25 | # Process and display mathematical expressions. This can clash with "$" characters in messages.
26 | latex = false
27 |
28 | # Automatically tag threads with the current chat profile (if a chat profile is used)
29 | auto_tag_thread = true
30 |
31 | # Authorize users to spontaneously upload files with messages
32 | [features.spontaneous_file_upload]
33 | enabled = true
34 | accept = ["*/*"]
35 | max_files = 20
36 | max_size_mb = 500
37 |
38 | [features.audio]
39 | # Threshold for audio recording
40 | min_decibels = -45
41 | # Delay for the user to start speaking in MS
42 | initial_silence_timeout = 3000
43 | # Delay for the user to continue speaking in MS. If the user stops speaking for this duration, the recording will stop.
44 | silence_timeout = 1500
45 | # Above this duration (MS), the recording will forcefully stop.
46 | max_duration = 15000
47 | # Duration of the audio chunks in MS
48 | chunk_duration = 1000
49 | # Sample rate of the audio
50 | sample_rate = 44100
51 |
52 | edit_message = true
53 |
54 | [UI]
55 | # Name of the assistant.
56 | name = "Quivr"
57 |
58 | # Description of the assistant. This is used for HTML tags.
59 | description = "Demo of Quivr"
60 |
61 | # Large size content are by default collapsed for a cleaner ui
62 | default_collapse_content = true
63 |
64 | # Chain of Thought (CoT) display mode. Can be "hidden", "tool_call" or "full".
65 | cot = "full"
66 |
67 | # Link to your github repo. This will add a github button in the UI's header.
68 | github = "https://github.com/quivrhq/quivr"
69 |
70 | # Specify a CSS file that can be used to customize the user interface.
71 | # The CSS file can be served from the public directory or via an external link.
72 | # custom_css = "/public/custom.css"
73 |
74 | # Specify a Javascript file that can be used to customize the user interface.
75 | # The Javascript file can be served from the public directory.
76 | # custom_js = "/public/test.js"
77 |
78 | # Specify a custom font url.
79 | # custom_font = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap"
80 |
81 | # Specify a custom meta image url.
82 | # custom_meta_image_url = "https://chainlit-cloud.s3.eu-west-3.amazonaws.com/logo/chainlit_banner.png"
83 |
84 | # Specify a custom build directory for the frontend.
85 | # This can be used to customize the frontend code.
86 | # Be careful: If this is a relative path, it should not start with a slash.
87 | # custom_build = "./public/build"
88 |
89 | [UI.theme]
90 | default = "dark"
91 | font_family = "Tahoma,Verdana,Segoe,sans-serif"
92 |
93 | # Override default MUI light theme. (Check theme.ts)
94 | [UI.theme.light]
95 | background = "#fcfcfc"
96 | paper = "#f8f8f8"
97 |
98 | [UI.theme.light.primary]
99 | main = "#6142d4"
100 | dark = "#6e53cf"
101 | light = "#6e53cf30"
102 | [UI.theme.light.text]
103 | primary = "#1f1f1f"
104 | secondary = "#818080"
105 |
106 | # Override default MUI dark theme. (Check theme.ts)
107 | [UI.theme.dark]
108 | background = "#252525"
109 | paper = "#1f1f1f"
110 |
111 | [UI.theme.dark.primary]
112 | main = "#6142d4"
113 | dark = "#6e53cf"
114 | light = "#6e53cf30"
115 | [UI.theme.dark.text]
116 | primary = "#f4f4f4"
117 | secondary = "#c8c8c8"
118 |
119 | [meta]
120 | generated_by = "1.1.402"
121 |
--------------------------------------------------------------------------------
/examples/chatbot/.gitignore:
--------------------------------------------------------------------------------
1 | # python generated files
2 | __pycache__/
3 | *.py[oc]
4 | build/
5 | dist/
6 | wheels/
7 | *.egg-info
8 |
9 | # venv
10 | .venv
11 | .files
--------------------------------------------------------------------------------
/examples/chatbot/.python-version:
--------------------------------------------------------------------------------
1 | 3.11.9
2 |
--------------------------------------------------------------------------------
/examples/chatbot/README.md:
--------------------------------------------------------------------------------
1 | # Quivr Chatbot Example
2 |
3 | This example demonstrates how to create a simple chatbot using Quivr and Chainlit. The chatbot allows users to upload a text file and then ask questions about its content.
4 |
5 | ## Prerequisites
6 |
7 | - Python 3.8 or higher
8 |
9 | ## Installation
10 |
11 | 1. Clone the repository and navigate to the `examples/chatbot` directory.
12 |
13 | 2. Make sure you have [rye](https://rye.astral.sh/) installed.
14 |
15 | 3. Install the requirements using `rye`:
16 |
17 | ```sh
18 | rye sync
19 | ```
20 | 4. Activate the venv
21 |
22 | ```sh
23 | source ./venv/bin/activate
24 | ```
25 |
26 | ## Running the Chatbot
27 |
28 | 1. Define your API key as environment variable. e.g. `export OPENAI_API_KEY=your-key-here`
29 |
30 | 2. Start the Chainlit server:
31 |
32 | ```
33 | chainlit run main.py
34 | ```
35 |
36 | 3. Open your web browser and go to the URL displayed in the terminal (usually `http://localhost:8000`).
37 |
38 | ## Using the Chatbot
39 |
40 | 1. When the chatbot interface loads, you will be prompted to upload a text file.
41 |
42 | 2. Click on the upload area and select a `.txt` file from your computer. The file size should not exceed 20MB.
43 |
44 | 3. After uploading, the chatbot will process the file and inform you when it's ready.
45 |
46 | 4. You can now start asking questions about the content of the uploaded file.
47 |
48 | 5. Type your questions in the chat input and press Enter. The chatbot will respond based on the information in the uploaded file.
49 |
50 | ## How It Works
51 |
52 | The chatbot uses the Quivr library to create a "brain" from the uploaded text file. This brain is then used to answer questions about the file's content. The Chainlit library provides the user interface and handles the chat interactions.
53 |
54 | Enjoy chatting with your documents!
55 |
--------------------------------------------------------------------------------
/examples/chatbot/basic_rag_workflow.yaml:
--------------------------------------------------------------------------------
1 | workflow_config:
2 | name: "standard RAG"
3 | nodes:
4 | - name: "START"
5 | edges: ["filter_history"]
6 |
7 | - name: "filter_history"
8 | edges: ["rewrite"]
9 |
10 | - name: "rewrite"
11 | edges: ["retrieve"]
12 |
13 | - name: "retrieve"
14 | edges: ["generate_rag"]
15 |
16 | - name: "generate_rag" # the name of the last node, from which we want to stream the answer to the user
17 | edges: ["END"]
18 | tools:
19 | - name: "cited_answer"
20 |
21 | # Maximum number of previous conversation iterations
22 | # to include in the context of the answer
23 | max_history: 10
24 |
25 | # Reranker configuration
26 | # reranker_config:
27 | # # The reranker supplier to use
28 | # supplier: "cohere"
29 |
30 | # # The model to use for the reranker for the given supplier
31 | # model: "rerank-multilingual-v3.0"
32 |
33 | # # Number of chunks returned by the reranker
34 | # top_n: 5
35 |
36 | # Configuration for the LLM
37 | llm_config:
38 |
39 | # maximum number of tokens passed to the LLM to generate the answer
40 | max_output_tokens: 4000
41 |
42 | # temperature for the LLM
43 | temperature: 0.7
44 |
--------------------------------------------------------------------------------
/examples/chatbot/chainlit.md:
--------------------------------------------------------------------------------
1 | # Quivr Chatbot Example
2 |
3 | This example demonstrates how to create a simple chatbot using Quivr and Chainlit. The chatbot allows users to upload a text file and then ask questions about its content.
4 |
5 | ## Prerequisites
6 |
7 | - Python 3.8 or higher
8 |
9 | ## Installation
10 |
11 | 1. Clone the repository or navigate to the `backend/core/examples/chatbot` directory.
12 |
13 | 2. Install the required dependencies:
14 |
15 | ```
16 | pip install -r requirements.txt
17 | ```
18 |
19 | ## Running the Chatbot
20 |
21 | 1. Start the Chainlit server:
22 |
23 | ```
24 | chainlit run main.py
25 | ```
26 |
27 | 2. Open your web browser and go to the URL displayed in the terminal (usually `http://localhost:8000`).
28 |
29 | ## Using the Chatbot
30 |
31 | 1. When the chatbot interface loads, you will be prompted to upload a text file.
32 |
33 | 2. Click on the upload area and select a `.txt` file from your computer. The file size should not exceed 20MB.
34 |
35 | 3. After uploading, the chatbot will process the file and inform you when it's ready.
36 |
37 | 4. You can now start asking questions about the content of the uploaded file.
38 |
39 | 5. Type your questions in the chat input and press Enter. The chatbot will respond based on the information in the uploaded file.
40 |
41 | ## How It Works
42 |
43 | The chatbot uses the Quivr library to create a "brain" from the uploaded text file. This brain is then used to answer questions about the file's content. The Chainlit library provides the user interface and handles the chat interactions.
44 |
45 | Enjoy chatting with your documents!
46 |
--------------------------------------------------------------------------------
/examples/chatbot/main.py:
--------------------------------------------------------------------------------
1 | import tempfile
2 |
3 | import chainlit as cl
4 | from quivr_core import Brain
5 | from quivr_core.rag.entities.config import RetrievalConfig
6 |
7 |
8 | @cl.on_chat_start
9 | async def on_chat_start():
10 | files = None
11 |
12 | # Wait for the user to upload a file
13 | while files is None:
14 | files = await cl.AskFileMessage(
15 | content="Please upload a text .txt file to begin!",
16 | accept=["text/plain"],
17 | max_size_mb=20,
18 | timeout=180,
19 | ).send()
20 |
21 | file = files[0]
22 |
23 | msg = cl.Message(content=f"Processing `{file.name}`...")
24 | await msg.send()
25 |
26 | with open(file.path, "r", encoding="utf-8") as f:
27 | text = f.read()
28 |
29 | with tempfile.NamedTemporaryFile(
30 | mode="w", suffix=file.name, delete=False
31 | ) as temp_file:
32 | temp_file.write(text)
33 | temp_file.flush()
34 | temp_file_path = temp_file.name
35 |
36 | brain = Brain.from_files(name="user_brain", file_paths=[temp_file_path])
37 |
38 | # Store the file path in the session
39 | cl.user_session.set("file_path", temp_file_path)
40 |
41 | # Let the user know that the system is ready
42 | msg.content = f"Processing `{file.name}` done. You can now ask questions!"
43 | await msg.update()
44 |
45 | cl.user_session.set("brain", brain)
46 |
47 |
48 | @cl.on_message
49 | async def main(message: cl.Message):
50 | brain = cl.user_session.get("brain") # type: Brain
51 | path_config = "basic_rag_workflow.yaml"
52 | retrieval_config = RetrievalConfig.from_yaml(path_config)
53 |
54 | if brain is None:
55 | await cl.Message(content="Please upload a file first.").send()
56 | return
57 |
58 | # Prepare the message for streaming
59 | msg = cl.Message(content="", elements=[])
60 | await msg.send()
61 |
62 | saved_sources = set()
63 | saved_sources_complete = []
64 | elements = []
65 |
66 | # Use the ask_stream method for streaming responses
67 | async for chunk in brain.ask_streaming(message.content, retrieval_config=retrieval_config):
68 | await msg.stream_token(chunk.answer)
69 | for source in chunk.metadata.sources:
70 | if source.page_content not in saved_sources:
71 | saved_sources.add(source.page_content)
72 | saved_sources_complete.append(source)
73 | print(source)
74 | elements.append(cl.Text(name=source.metadata["original_file_name"], content=source.page_content, display="side"))
75 |
76 |
77 | await msg.send()
78 | sources = ""
79 | for source in saved_sources_complete:
80 | sources += f"- {source.metadata['original_file_name']}\n"
81 | msg.elements = elements
82 | msg.content = msg.content + f"\n\nSources:\n{sources}"
83 | await msg.update()
--------------------------------------------------------------------------------
/examples/chatbot/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot/public/favicon.ico
--------------------------------------------------------------------------------
/examples/chatbot/public/logo_dark.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot/public/logo_dark.png
--------------------------------------------------------------------------------
/examples/chatbot/public/logo_light.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot/public/logo_light.png
--------------------------------------------------------------------------------
/examples/chatbot/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "chatbot"
3 | version = "0.1.0"
4 | description = "Add your description here"
5 | authors = [
6 | { name = "Stan Girard", email = "stan@quivr.app" }
7 | ]
8 | dependencies = [
9 | "quivr-core @ file:///${PROJECT_ROOT}/../../core",
10 | "chainlit>=1.2.0",
11 | ]
12 | readme = "README.md"
13 | requires-python = ">= 3.11"
14 |
15 | [tool.rye]
16 | managed = true
17 | virtual = true
18 | dev-dependencies = []
19 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/.chainlit/config.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | # Whether to enable telemetry (default: true). No personal data is collected.
3 | enable_telemetry = true
4 |
5 |
6 | # List of environment variables to be provided by each user to use the app.
7 | user_env = []
8 |
9 | # Duration (in seconds) during which the session is saved when the connection is lost
10 | session_timeout = 3600
11 |
12 | # Enable third parties caching (e.g LangChain cache)
13 | cache = false
14 |
15 | # Authorized origins
16 | allow_origins = ["*"]
17 |
18 | # Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
19 | # follow_symlink = false
20 |
21 | [features]
22 | # Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
23 | unsafe_allow_html = false
24 |
25 | # Process and display mathematical expressions. This can clash with "$" characters in messages.
26 | latex = false
27 |
28 | # Automatically tag threads with the current chat profile (if a chat profile is used)
29 | auto_tag_thread = true
30 |
31 | # Authorize users to spontaneously upload files with messages
32 | [features.spontaneous_file_upload]
33 | enabled = false
34 | accept = ["*/*"]
35 | max_files = 20
36 | max_size_mb = 500
37 |
38 | [features.audio]
39 | # Threshold for audio recording
40 | min_decibels = -45
41 | # Delay for the user to start speaking in MS
42 | initial_silence_timeout = 3000
43 | # Delay for the user to continue speaking in MS. If the user stops speaking for this duration, the recording will stop.
44 | silence_timeout = 1500
45 | # Above this duration (MS), the recording will forcefully stop.
46 | max_duration = 15000
47 | # Duration of the audio chunks in MS
48 | chunk_duration = 1000
49 | # Sample rate of the audio
50 | sample_rate = 44100
51 |
52 | edit_message = true
53 |
54 | [UI]
55 | # Name of the assistant.
56 | name = "Quivr"
57 |
58 | # Description of the assistant. This is used for HTML tags.
59 | description = "Demo of Quivr"
60 |
61 | # Large size content are by default collapsed for a cleaner ui
62 | default_collapse_content = true
63 |
64 | # Chain of Thought (CoT) display mode. Can be "hidden", "tool_call" or "full".
65 | cot = "hidden"
66 |
67 | # Link to your github repo. This will add a github button in the UI's header.
68 | github = "https://github.com/quivrhq/quivr"
69 |
70 | # Specify a CSS file that can be used to customize the user interface.
71 | # The CSS file can be served from the public directory or via an external link.
72 | # custom_css = "/public/style.css"
73 |
74 | # Specify a Javascript file that can be used to customize the user interface.
75 | # The Javascript file can be served from the public directory.
76 | # custom_js = "/public/test.js"
77 |
78 | # Specify a custom font url.
79 | # custom_font = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap"
80 |
81 | # Specify a custom meta image url.
82 | # custom_meta_image_url = "https://chainlit-cloud.s3.eu-west-3.amazonaws.com/logo/chainlit_banner.png"
83 |
84 | # Specify a custom build directory for the frontend.
85 | # This can be used to customize the frontend code.
86 | # Be careful: If this is a relative path, it should not start with a slash.
87 | # custom_build = "./public/build"
88 |
89 | [UI.theme]
90 | default = "dark"
91 | font_family = "Tahoma,Verdana,Segoe,sans-serif"
92 |
93 | # Override default MUI light theme. (Check theme.ts)
94 | [UI.theme.light]
95 | background = "#fcfcfc"
96 | paper = "#f8f8f8"
97 |
98 | [UI.theme.light.primary]
99 | main = "#6142d4"
100 | dark = "#6e53cf"
101 | light = "#6e53cf30"
102 | [UI.theme.light.text]
103 | primary = "#1f1f1f"
104 | secondary = "#818080"
105 |
106 | # Override default MUI dark theme. (Check theme.ts)
107 | [UI.theme.dark]
108 | background = "#252525"
109 | paper = "#1f1f1f"
110 |
111 | [UI.theme.dark.primary]
112 | main = "#6142d4"
113 | dark = "#6e53cf"
114 | light = "#6e53cf30"
115 | [UI.theme.dark.text]
116 | primary = "#f4f4f4"
117 | secondary = "#c8c8c8"
118 |
119 | [meta]
120 | generated_by = "1.1.402"
121 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/.gitignore:
--------------------------------------------------------------------------------
1 | # python generated files
2 | __pycache__/
3 | *.py[oc]
4 | build/
5 | dist/
6 | wheels/
7 | *.egg-info
8 |
9 | # venv
10 | .venv
11 | .files
--------------------------------------------------------------------------------
/examples/chatbot_voice/.python-version:
--------------------------------------------------------------------------------
1 | 3.11.9
2 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/README.md:
--------------------------------------------------------------------------------
1 | # Quivr Chatbot Example
2 |
3 | This example demonstrates how to create a simple chatbot using Quivr and Chainlit. The chatbot allows users to upload a text file and then ask questions about its content.
4 |
5 | ## Prerequisites
6 |
7 | - Python 3.8 or higher
8 |
9 | ## Installation
10 |
11 | 1. Clone the repository or navigate to the `core/examples/chatbot` directory.
12 |
13 | 2. Install the required dependencies:
14 |
15 | ```
16 | pip install -r requirements.lock
17 | ```
18 |
19 | ## Running the Chatbot
20 |
21 | 1. Start the Chainlit server:
22 |
23 | ```
24 | chainlit run main.py
25 | ```
26 |
27 | 2. Open your web browser and go to the URL displayed in the terminal (usually `http://localhost:8000`).
28 |
29 | ## Using the Chatbot
30 |
31 | 1. When the chatbot interface loads, you will be prompted to upload a text file.
32 |
33 | 2. Click on the upload area and select a `.txt` file from your computer. The file size should not exceed 20MB.
34 |
35 | 3. After uploading, the chatbot will process the file and inform you when it's ready.
36 |
37 | 4. You can now start asking questions about the content of the uploaded file.
38 |
39 | 5. Type your questions in the chat input and press Enter. The chatbot will respond based on the information in the uploaded file.
40 |
41 | ## How It Works
42 |
43 | The chatbot uses the Quivr library to create a "brain" from the uploaded text file. This brain is then used to answer questions about the file's content. The Chainlit library provides the user interface and handles the chat interactions.
44 |
45 | Enjoy chatting with your documents!
46 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/basic_rag_workflow.yaml:
--------------------------------------------------------------------------------
1 | workflow_config:
2 | name: "standard RAG"
3 | nodes:
4 | - name: "START"
5 | edges: ["filter_history"]
6 |
7 | - name: "filter_history"
8 | edges: ["rewrite"]
9 |
10 | - name: "rewrite"
11 | edges: ["retrieve"]
12 |
13 | - name: "retrieve"
14 | edges: ["generate_rag"]
15 |
16 | - name: "generate_rag" # the name of the last node, from which we want to stream the answer to the user
17 | edges: ["END"]
18 |
19 | # Maximum number of previous conversation iterations
20 | # to include in the context of the answer
21 | max_history: 10
22 |
23 | # Reranker configuration
24 | # reranker_config:
25 | # # The reranker supplier to use
26 | # supplier: "cohere"
27 |
28 | # # The model to use for the reranker for the given supplier
29 | # model: "rerank-multilingual-v3.0"
30 |
31 | # # Number of chunks returned by the reranker
32 | # top_n: 5
33 |
34 | # Configuration for the LLM
35 | llm_config:
36 |
37 | # maximum number of tokens passed to the LLM to generate the answer
38 | max_output_tokens: 4000
39 |
40 | # temperature for the LLM
41 | temperature: 0.7
42 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/chainlit.md:
--------------------------------------------------------------------------------
1 | # Quivr Chatbot Example
2 |
3 | This example demonstrates how to create a simple chatbot using Quivr and Chainlit. The chatbot allows users to upload a text file and then ask questions about its content.
4 |
5 | ## Prerequisites
6 |
7 | - Python 3.8 or higher
8 |
9 | ## Installation
10 |
11 | 1. Clone the repository or navigate to the `backend/core/examples/chatbot` directory.
12 |
13 | 2. Install the required dependencies:
14 |
15 | ```
16 | pip install -r requirements.txt
17 | ```
18 |
19 | ## Running the Chatbot
20 |
21 | 1. Start the Chainlit server:
22 |
23 | ```
24 | chainlit run main.py
25 | ```
26 |
27 | 2. Open your web browser and go to the URL displayed in the terminal (usually `http://localhost:8000`).
28 |
29 | ## Using the Chatbot
30 |
31 | 1. When the chatbot interface loads, you will be prompted to upload a text file.
32 |
33 | 2. Click on the upload area and select a `.txt` file from your computer. The file size should not exceed 20MB.
34 |
35 | 3. After uploading, the chatbot will process the file and inform you when it's ready.
36 |
37 | 4. You can now start asking questions about the content of the uploaded file.
38 |
39 | 5. Type your questions in the chat input and press Enter. The chatbot will respond based on the information in the uploaded file.
40 |
41 | ## How It Works
42 |
43 | The chatbot uses the Quivr library to create a "brain" from the uploaded text file. This brain is then used to answer questions about the file's content. The Chainlit library provides the user interface and handles the chat interactions.
44 |
45 | Enjoy chatting with your documents!
46 |
--------------------------------------------------------------------------------
/examples/chatbot_voice/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot_voice/public/favicon.ico
--------------------------------------------------------------------------------
/examples/chatbot_voice/public/logo_dark.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot_voice/public/logo_dark.png
--------------------------------------------------------------------------------
/examples/chatbot_voice/public/logo_light.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/examples/chatbot_voice/public/logo_light.png
--------------------------------------------------------------------------------
/examples/chatbot_voice/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "chatbot"
3 | version = "0.1.0"
4 | description = "Add your description here"
5 | authors = [
6 | { name = "Stan Girard", email = "stan@quivr.app" }
7 | ]
8 | dependencies = [
9 | "quivr-core @ file:///${PROJECT_ROOT}/../../core",
10 | "chainlit>=1.2.0",
11 | "openai>=1.54.5",
12 | ]
13 | readme = "README.md"
14 | requires-python = ">= 3.11"
15 |
16 | [tool.rye]
17 | managed = true
18 | virtual = true
19 | dev-dependencies = []
20 |
--------------------------------------------------------------------------------
/examples/pdf_parsing_tika.py:
--------------------------------------------------------------------------------
1 | from langchain_core.embeddings import DeterministicFakeEmbedding
2 | from langchain_core.language_models import FakeListChatModel
3 | from quivr_core import Brain
4 | from quivr_core.rag.entities.config import LLMEndpointConfig
5 | from quivr_core.llm.llm_endpoint import LLMEndpoint
6 | from rich.console import Console
7 | from rich.panel import Panel
8 | from rich.prompt import Prompt
9 |
10 | if __name__ == "__main__":
11 | brain = Brain.from_files(
12 | name="test_brain",
13 | file_paths=["tests/processor/data/dummy.pdf"],
14 | llm=LLMEndpoint(
15 | llm=FakeListChatModel(responses=["good"]),
16 | llm_config=LLMEndpointConfig(model="fake_model", llm_base_url="local"),
17 | ),
18 | embedder=DeterministicFakeEmbedding(size=20),
19 | )
20 | # Check brain info
21 | brain.print_info()
22 |
23 | console = Console()
24 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
25 |
26 | while True:
27 | # Get user input
28 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
29 |
30 | # Check if user wants to exit
31 | if question.lower() == "exit":
32 | console.print(Panel("Goodbye!", style="bold yellow"))
33 | break
34 |
35 | answer = brain.ask(question)
36 | # Print the answer with typing effect
37 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
38 |
39 | console.print("-" * console.width)
40 |
41 | brain.print_info()
42 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/.env_example:
--------------------------------------------------------------------------------
1 | QUIVR_API_KEY=XXXX
2 | QUIVR_CHAT_ID=1XXXX
3 | QUIVR_BRAIN_ID=XXXX
4 | QUIVR_URL=XXXX
5 | OPENAI_API_KEY=XXXX
6 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/.gitignore:
--------------------------------------------------------------------------------
1 | .env
2 | uploads
--------------------------------------------------------------------------------
/examples/quivr-whisper/.python-version:
--------------------------------------------------------------------------------
1 | 3.11.9
2 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/README.md:
--------------------------------------------------------------------------------
1 | # Quivr-Whisper
2 |
3 | Quivr-Whisper is a web application that allows users to ask questions via audio input. It leverages OpenAI's Whisper model for speech transcription and synthesizes responses using OpenAI's text-to-speech capabilities. The application queries the Quivr API to get a response based on the transcribed audio input.
4 |
5 |
6 |
7 | https://github.com/StanGirard/quivr-whisper/assets/19614572/9cc270c9-07e4-4ce1-bcff-380f195c9313
8 |
9 |
10 |
11 | ## Features
12 |
13 | - Audio input for asking questions
14 | - Speech transcription using OpenAI's Whisper model
15 | - Integration with Quivr API for intelligent responses
16 | - Speech synthesis of the response for audio playback
17 |
18 | ## Getting Started
19 |
20 | These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
21 |
22 | ### Prerequisites
23 |
24 | What things you need to install the software and how to install them:
25 |
26 | - Python 3.6+
27 | - pip for Python 3
28 | - Flask
29 | - OpenAI Python package
30 | - Requests package
31 |
32 | ### Installing
33 |
34 | A step by step series of examples that tell you how to get a development environment running:
35 |
36 | 1. Clone the repository to your local machine.
37 | ```bash
38 | git clone https://github.com/stangirard/quivr-whisper.git
39 | cd Quivr-talk
40 | ```
41 |
42 | 2. Install the required packages.
43 | ```bash
44 | pip install flask openai requests python-dotenv
45 | ```
46 |
47 | 3. Create a `.env` file in the root directory of the project and add your API keys and other configuration variables.
48 | ```env
49 | OPENAI_API_KEY='your_openai_api_key'
50 | QUIVR_API_KEY='your_quivr_api_key'
51 | QUIVR_CHAT_ID='your_quivr_chat_id'
52 | QUIVR_BRAIN_ID='your_quivr_brain_id'
53 | QUIVR_URL='https://api.quivr.app' # Optional, only if different from the default
54 | ```
55 |
56 | 4. Run the Flask application.
57 | ```bash
58 | flask run
59 | ```
60 |
61 | Your app should now be running on `http://localhost:5000`.
62 |
63 | ## Usage
64 |
65 | To use Quivr-talk, navigate to `http://localhost:5000` in your web browser, click on "Ask a question to Quivr", and record your question. Wait for the transcription and response to be synthesized, and you will hear the response played back to you.
66 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, render_template, request, jsonify, session
2 | import openai
3 | import base64
4 | import os
5 | import requests
6 | from dotenv import load_dotenv
7 | from quivr_core import Brain
8 | from quivr_core.rag.entities.config import RetrievalConfig
9 | from tempfile import NamedTemporaryFile
10 | from werkzeug.utils import secure_filename
11 | from asyncio import to_thread
12 | import asyncio
13 |
14 |
15 | UPLOAD_FOLDER = "uploads"
16 | ALLOWED_EXTENSIONS = {"txt"}
17 |
18 | os.makedirs(UPLOAD_FOLDER, exist_ok=True)
19 |
20 | app = Flask(__name__)
21 | app.secret_key = "secret"
22 | app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
23 | app.config["CACHE_TYPE"] = "SimpleCache" # In-memory cache for development
24 | app.config["CACHE_DEFAULT_TIMEOUT"] = 60 * 60 # 1 hour cache timeout
25 | load_dotenv()
26 |
27 | openai.api_key = os.getenv("OPENAI_API_KEY")
28 |
29 | brains = {}
30 |
31 |
32 | @app.route("/")
33 | def index():
34 | return render_template("index.html")
35 |
36 |
37 | def run_in_event_loop(func, *args, **kwargs):
38 | loop = asyncio.new_event_loop()
39 | asyncio.set_event_loop(loop)
40 | if asyncio.iscoroutinefunction(func):
41 | result = loop.run_until_complete(func(*args, **kwargs))
42 | else:
43 | result = func(*args, **kwargs)
44 | loop.close()
45 | return result
46 |
47 |
48 | def allowed_file(filename):
49 | return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
50 |
51 |
52 | @app.route("/upload", methods=["POST"])
53 | async def upload_file():
54 | if "file" not in request.files:
55 | return "No file part", 400
56 |
57 | file = request.files["file"]
58 |
59 | if file.filename == "":
60 | return "No selected file", 400
61 | if not (file and file.filename and allowed_file(file.filename)):
62 | return "Invalid file type", 400
63 |
64 | filename = secure_filename(file.filename)
65 | filepath = os.path.join(app.config["UPLOAD_FOLDER"], filename)
66 | file.save(filepath)
67 |
68 | print(f"File uploaded and saved at: {filepath}")
69 |
70 | print("Creating brain instance...")
71 |
72 | brain: Brain = await to_thread(
73 | run_in_event_loop, Brain.from_files, name="user_brain", file_paths=[filepath]
74 | )
75 |
76 | # Store brain instance in cache
77 | session_id = session.sid if hasattr(session, "sid") else os.urandom(16).hex()
78 | session["session_id"] = session_id
79 | # cache.set(session_id, brain) # Store the brain instance in the cache
80 | brains[session_id] = brain
81 | print(f"Brain instance created and stored in cache for session ID: {session_id}")
82 |
83 | return jsonify({"message": "Brain created successfully"})
84 |
85 |
86 | @app.route("/ask", methods=["POST"])
87 | async def ask():
88 | if "audio_data" not in request.files:
89 | return "Missing audio data", 400
90 |
91 | # Retrieve the brain instance from the cache using the session ID
92 | session_id = session.get("session_id")
93 | if not session_id:
94 | return "Session ID not found. Upload a file first.", 400
95 |
96 | brain = brains.get(session_id)
97 | if not brain:
98 | return "Brain instance not found in dict. Upload a file first.", 400
99 |
100 | print("Brain instance loaded from cache.")
101 |
102 | print("Speech to text...")
103 | audio_file = request.files["audio_data"]
104 | transcript = transcribe_audio_file(audio_file)
105 | print("Transcript result: ", transcript)
106 |
107 | print("Getting response...")
108 | quivr_response = await to_thread(run_in_event_loop, brain.ask, transcript)
109 |
110 | print("Text to speech...")
111 | audio_base64 = synthesize_speech(quivr_response.answer)
112 |
113 | print("Done")
114 | return jsonify({"audio_base64": audio_base64})
115 |
116 |
117 | def transcribe_audio_file(audio_file):
118 | with NamedTemporaryFile(suffix=".webm", delete=False) as temp_audio_file:
119 | audio_file.save(temp_audio_file)
120 | temp_audio_file_path = temp_audio_file.name
121 |
122 | try:
123 | with open(temp_audio_file_path, "rb") as f:
124 | transcript_response = openai.audio.transcriptions.create(
125 | model="whisper-1", file=f
126 | )
127 | transcript = transcript_response.text
128 | finally:
129 | os.unlink(temp_audio_file_path)
130 |
131 | return transcript
132 |
133 |
134 | def synthesize_speech(text):
135 | speech_response = openai.audio.speech.create(
136 | model="tts-1", voice="nova", input=text
137 | )
138 | audio_content = speech_response.content
139 | audio_base64 = base64.b64encode(audio_content).decode("utf-8")
140 | return audio_base64
141 |
142 |
143 | if __name__ == "__main__":
144 | app.run(debug=True)
145 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "quivr-whisper"
3 | version = "0.1.0"
4 | description = "Add your description here"
5 | authors = [
6 | { name = "Stan Girard", email = "stan@quivr.app" }
7 | ]
8 | dependencies = [
9 | "quivr-core @ file:///${PROJECT_ROOT}/../../core",
10 | "flask[async]>=3.1.0",
11 | "openai>=1.54.5",
12 | "flask-caching>=2.3.0",
13 | ]
14 | readme = "README.md"
15 | requires-python = ">= 3.11"
16 |
17 | [build-system]
18 | requires = ["hatchling"]
19 | build-backend = "hatchling.build"
20 |
21 | [tool.rye]
22 | managed = true
23 | virtual = true
24 | dev-dependencies = []
25 |
26 | [tool.hatch.metadata]
27 | allow-direct-references = true
28 |
29 | [tool.hatch.build.targets.wheel]
30 | packages = ["src/quivr_whisper"]
31 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/static/loader.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/static/mic-off.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/static/mic.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/examples/quivr-whisper/static/styles.css:
--------------------------------------------------------------------------------
1 | * {
2 | box-sizing: border-box;
3 | margin: 0;
4 | padding: 0;
5 | }
6 |
7 |
8 | body {
9 | color: #f4f4f4;
10 | background-color: #252525;
11 | display: flex;
12 | gap: 1rem;
13 | align-items: center;
14 | flex-direction: column;
15 | justify-content: center;
16 | min-height: 100vh;
17 | }
18 |
19 | .primary {
20 | background-color: #6142d4;
21 | }
22 |
23 | button {
24 | background-color: #6142d4;
25 | border: none;
26 | padding: .75rem 2rem;
27 | border-radius: 0.5rem;
28 | color: #f4f4f4;
29 | cursor: pointer;
30 | }
31 |
32 | canvas {
33 | position: absolute;
34 | width: 100%;
35 | height: 100%;
36 | top: 0;
37 | left: 0;
38 | background-color: #252525;
39 | z-index: -1;
40 | }
41 |
42 | .record-btn {
43 | background-color: #f5f5f5;
44 | border: none;
45 | outline: none;
46 | width: 256px;
47 | height: 256px;
48 | background-repeat: no-repeat;
49 | background-position: center;
50 | border-radius: 50%;
51 | background-size: 50%;
52 | transition: background-color 200ms ease-in, transform 200ms ease-out;
53 | }
54 |
55 | .record-btn:hover {
56 | background-color: #fff;
57 | transform: scale(1.025);
58 | }
59 |
60 | .record-btn:active {
61 | background-color: #e2e2e2;
62 | transform: scale(0.975);
63 | }
64 |
65 | .record-btn[data-recording="true"] {
66 | background-image: url("./mic.svg");
67 | }
68 |
69 | .record-btn[data-recording="false"] {
70 | background-image: url("./mic-off.svg");
71 | }
72 |
73 | .record-btn[data-pending="true"] {
74 | background-image: url("./loader.svg") !important;
75 | animation: spin 1s linear infinite;
76 | }
77 |
78 | .hidden {
79 | display: none !important;
80 | visibility: hidden;
81 | }
82 |
83 | .custom-file-input {
84 | display: flex;
85 | flex-direction: column;
86 | align-items: center;
87 | gap: 10px;
88 | }
89 |
90 | .custom-file-input input[type="file"] {
91 | display: none;
92 | }
93 |
94 | .custom-file-input label {
95 | border: solid 2px #6142d4;
96 | color: white;
97 | padding: 8px 16px;
98 | border-radius: 4px;
99 | cursor: pointer;
100 | font-size: 14px;
101 | font-weight: bold;
102 | transition: background-color 0.3s;
103 | }
104 |
105 | .custom-file-input label:hover {
106 | background-color: #6142d4;
107 | }
108 |
109 | .custom-file-input span {
110 | font-size: 14px;
111 | color: #f4f4f4;
112 | }
113 |
114 | /* Adjust appearance when a file is selected */
115 | .custom-file-input span.file-selected {
116 | color: #ffffff;
117 | font-weight: bold;
118 | }
119 |
120 | /*
121 | # Override default MUI light theme. (Check theme.ts)
122 | [UI.theme.light]
123 | background = "#fcfcfc"
124 | paper = "#f8f8f8"
125 |
126 | [UI.theme.light.primary]
127 | main = "#6142d4"
128 | dark = "#6e53cf"
129 | light = "#6e53cf30"
130 | [UI.theme.light.text]
131 | primary = "#1f1f1f"
132 | secondary = "#818080"
133 |
134 | # Override default MUI dark theme. (Check theme.ts)
135 | [UI.theme.dark]
136 | background = "#252525"
137 | paper = "#1f1f1f"
138 |
139 | [UI.theme.dark.primary]
140 | main = "#6142d4"
141 | dark = "#6e53cf"
142 | light = "#6e53cf30"
143 | [UI.theme.dark.text]
144 | primary = "#f4f4f4"
145 | secondary = "#c8c8c8"
146 |
147 | */
148 |
149 | .loader {
150 | border: 4px solid #f3f3f3;
151 | border-radius: 50%;
152 | border-top: 4px solid #3498db;
153 | width: 50px;
154 | height: 50px;
155 | -webkit-animation: spin 2s linear infinite;
156 | animation: spin 2s linear infinite;
157 | position: absolute;
158 | /* Center the loader in the viewport */
159 | top: 50%;
160 | left: 50%;
161 | transform: translate(-50%, -50%);
162 | display: none;
163 | /* Hide it by default */
164 | }
165 |
166 | @-webkit-keyframes spin {
167 | 0% {
168 | -webkit-transform: rotate(0deg);
169 | }
170 |
171 | 100% {
172 | -webkit-transform: rotate(360deg);
173 | }
174 | }
175 |
176 | @keyframes spin {
177 | 0% {
178 | transform: rotate(0deg);
179 | }
180 |
181 | 100% {
182 | transform: rotate(360deg);
183 | }
184 | }
--------------------------------------------------------------------------------
/examples/quivr-whisper/templates/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Audio Interaction WebApp
7 |
11 |
12 |
13 |
14 |
21 |
22 |
23 |
30 | No file chosen
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
--------------------------------------------------------------------------------
/examples/save_load_brain.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import tempfile
3 |
4 | from quivr_core import Brain
5 |
6 |
7 | async def main():
8 | with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
9 | temp_file.write("Gold is a liquid of blue-like colour.")
10 | temp_file.flush()
11 |
12 | brain = await Brain.afrom_files(name="test_brain", file_paths=[temp_file.name])
13 |
14 | save_path = await brain.save("/home/amine/.local/quivr")
15 |
16 | brain_loaded = Brain.load(save_path)
17 | brain_loaded.print_info()
18 |
19 |
20 | if __name__ == "__main__":
21 | # Run the main function in the existing event loop
22 | asyncio.run(main())
23 |
--------------------------------------------------------------------------------
/examples/simple_question/.gitignore:
--------------------------------------------------------------------------------
1 | # python generated files
2 | __pycache__/
3 | *.py[oc]
4 | build/
5 | dist/
6 | wheels/
7 | *.egg-info
8 |
9 | # venv
10 | .venv
11 |
--------------------------------------------------------------------------------
/examples/simple_question/.python-version:
--------------------------------------------------------------------------------
1 | 3.11.9
2 |
--------------------------------------------------------------------------------
/examples/simple_question/README.md:
--------------------------------------------------------------------------------
1 | # simple-question
2 |
3 | Describe your project here.
4 |
--------------------------------------------------------------------------------
/examples/simple_question/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "simple-question"
3 | version = "0.1.0"
4 | description = "Add your description here"
5 | authors = [
6 | { name = "Stan Girard", email = "stan@quivr.app" }
7 | ]
8 | dependencies = [
9 | "quivr-core @ file:///${PROJECT_ROOT}/../../core",
10 | "python-dotenv>=1.0.1",
11 | ]
12 | readme = "README.md"
13 | requires-python = ">= 3.11"
14 |
15 | [tool.rye]
16 | managed = true
17 | virtual = true
18 | dev-dependencies = []
19 |
--------------------------------------------------------------------------------
/examples/simple_question/simple_question.py:
--------------------------------------------------------------------------------
1 | import tempfile
2 |
3 | from quivr_core import Brain
4 |
5 | import dotenv
6 |
7 | dotenv.load_dotenv()
8 |
9 | if __name__ == "__main__":
10 | with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
11 | temp_file.write("Gold is a liquid of blue-like colour.")
12 | temp_file.flush()
13 |
14 | brain = Brain.from_files(
15 | name="test_brain",
16 | file_paths=[temp_file.name],
17 | )
18 |
19 | answer = brain.ask("what is gold? answer in french")
20 | print("answer QuivrQARAGLangGraph :", answer)
21 |
--------------------------------------------------------------------------------
/examples/simple_question/simple_question_streaming.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import tempfile
3 |
4 | from dotenv import load_dotenv
5 | from quivr_core import Brain
6 | from quivr_core.quivr_rag import QuivrQARAG
7 | from quivr_core.rag.quivr_rag_langgraph import QuivrQARAGLangGraph
8 |
9 |
10 | async def main():
11 | dotenv_path = "/Users/jchevall/Coding/QuivrHQ/quivr/.env"
12 | load_dotenv(dotenv_path)
13 |
14 | with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
15 | temp_file.write("Gold is a liquid of blue-like colour.")
16 | temp_file.flush()
17 |
18 | brain = await Brain.afrom_files(name="test_brain", file_paths=[temp_file.name])
19 |
20 | await brain.save("~/.local/quivr")
21 |
22 | question = "what is gold? answer in french"
23 | async for chunk in brain.ask_streaming(question, rag_pipeline=QuivrQARAG):
24 | print("answer QuivrQARAG:", chunk.answer)
25 |
26 | async for chunk in brain.ask_streaming(
27 | question, rag_pipeline=QuivrQARAGLangGraph
28 | ):
29 | print("answer QuivrQARAGLangGraph:", chunk.answer)
30 |
31 |
32 | if __name__ == "__main__":
33 | # Run the main function in the existing event loop
34 | asyncio.run(main())
35 |
--------------------------------------------------------------------------------
/examples/simple_question_megaparse.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | from langchain_openai import ChatOpenAI, OpenAIEmbeddings
4 | from quivr_core import Brain
5 | from quivr_core.llm.llm_endpoint import LLMEndpoint
6 | from quivr_core.rag.entities.config import LLMEndpointConfig
7 | from rich.console import Console
8 | from rich.panel import Panel
9 | from rich.prompt import Prompt
10 |
11 | if __name__ == "__main__":
12 | brain = Brain.from_files(
13 | name="test_brain",
14 | file_paths=["./tests/processor/pdf/sample.pdf"],
15 | llm=LLMEndpoint(
16 | llm_config=LLMEndpointConfig(model="gpt-4o"),
17 | llm=ChatOpenAI(model="gpt-4o", api_key=str(os.getenv("OPENAI_API_KEY"))),
18 | ),
19 | )
20 | embedder = embeddings = OpenAIEmbeddings(
21 | model="text-embedding-3-large",
22 | )
23 | # Check brain info
24 | brain.print_info()
25 |
26 | console = Console()
27 | console.print(Panel.fit("Ask your brain !", style="bold magenta"))
28 |
29 | while True:
30 | # Get user input
31 | question = Prompt.ask("[bold cyan]Question[/bold cyan]")
32 |
33 | # Check if user wants to exit
34 | if question.lower() == "exit":
35 | console.print(Panel("Goodbye!", style="bold yellow"))
36 | break
37 |
38 | answer = brain.ask(question)
39 | # Print the answer with typing effect
40 | console.print(f"[bold green]Quivr Assistant[/bold green]: {answer.answer}")
41 |
42 | console.print("-" * console.width)
43 |
44 | brain.print_info()
45 |
--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/QuivrHQ/quivr/5dd44d8eb37b25e9d7c14c14df47f19849cdd031/logo.png
--------------------------------------------------------------------------------
/release-please-config.json:
--------------------------------------------------------------------------------
1 | {
2 | "packages": {
3 | "core": {
4 | "release-type": "python",
5 | "package-name": "core",
6 | "bump-patch-for-minor-pre-major": true,
7 | "include-v-in-tag": false,
8 | "tag-separator": "-",
9 | "component": "core"
10 | }
11 | }
12 | }
--------------------------------------------------------------------------------
/vercel.json:
--------------------------------------------------------------------------------
1 | {
2 | "git": {
3 | "deploymentEnabled": {
4 | "main": false
5 | }
6 | }
7 | }
--------------------------------------------------------------------------------