Arbitrating between multiple bots for RAG

[ibikestl]

Had a bit of fun with the RAG notebook and got a few bots discussing questions with each other and assigning one to abitrate amongst them.

First, I set up a document and memory store for each of the bots. Perhaps I could have used the same document store as I assume it's read-only and all the bots should use the same corpus:

phi_knowledge_store = LanceDBDocStore(table_name="phi-zenthing-memory-store")
phi_memory_store = LanceDBDocStore(table_name="phi-zenthing-chat-memory")

llama_knowledge_store = LanceDBDocStore(table_name="llama-zenthing-memory-store")
llama_memory_store = LanceDBDocStore(table_name="llama-zenthing-chat-memory")

gemma_knowledge_store = LanceDBDocStore(table_name="gemma-zenthing-memory-store")
gemma_memory_store = LanceDBDocStore(table_name="gemma-zenthing-chat-memory")

mclaughlin_knowledge_store = LanceDBDocStore(table_name="mclaghlin-zenthing-memory-store")
mclaughlin_memory_store = LanceDBDocStore(table_name="mclaughlin-zenthing-chat-memory")

I added the documents to each knowledge store:

# Sample documents about a new programming language named Zenthing
from building_with_llms_made_simple.answers.rag_answers import (
    zenthing_ecosystem_use_cases_text,
    zenthing_language_features_text,
    zenthing_overview_text,
    zenthing_syntax_and_programming_style_text,
)

zenthing_docs = [
    zenthing_ecosystem_use_cases_text,
    zenthing_language_features_text,
    zenthing_overview_text,
    zenthing_syntax_and_programming_style_text,
]

# Add documents to knowledge store
knowledge_store.extend(zenthing_docs)  # Using extend for bulk addition
phi_knowledge_store.extend(zenthing_docs)  # Using extend for bulk addition
gemma_knowledge_store.extend(zenthing_docs)  # Using extend for bulk addition
llama_knowledge_store.extend(zenthing_docs)  # Using extend for bulk addition
mclaughlin_knowledge_store.extend(zenthing_docs)  # Using extend for bulk addition

Then I created all of the bots. Three bots got the same prompt, one was a bit different to arbitrate:

# Create the QueryBot
querybot_phi = lmb.QueryBot(system_prompt="You are an expert in the Zenthing programming language", docstore=phi_knowledge_store, memory=phi_memory_store, model_name="ollama/phi4")
querybot_gemma = lmb.QueryBot(system_prompt="You are an expert in the Zenthing programming language", docstore=gemma_knowledge_store, memory=gemma_memory_store, model_name="ollama/gemma2:2b")
querybot_llama =  lmb.QueryBot(system_prompt="You are an expert in the Zenthing programming language", docstore=llama_knowledge_store, memory=llama_memory_store, model_name="ollama/llama3.2")
querybot_mclaughlin = lmb.QueryBot(system_prompt="You are an arbitrator between three different alleged experts in the Zenthing programming language. You will arbitrate their discussion and provide commentary in the style of John McLaughlin from the long running PBS TV series 'The McLaughlin Group'", docstore=mclaughlin_knowledge_store, memory=mclaughlin_memory_store, model_name="ollama/llama3.2")

You can now arbitrate amongst the bots:

result_phi = querybot_phi("what is Zenthing")
result_gemma = querybot_gemma("what is Zenthing")
result_llama = querybot_llama("what is Zenthing")
result_mclaughlin = querybot_mclaughlin(f"Arbitrate between these three experts. Tell me which answer is correct and call out the ones that are incorrect.\nGemma:\nf{result_gemma}\n\nLlama:\nf{result_llama}\n\nPhi:\nf{result_phi}\n")

Initial results

Zenthing appears to be a fictional or hypothetical programming language described in the text you provided. It's not an actual, existing language but rather a detailed conceptualization that combines features from modern programming languages like Python. Here are some key aspects of what "Zenthing" encompasses based on your description:

1. **Syntax and Features**: Zenthing emphasizes readability and expressiveness, supporting both object-oriented (OOP) and functional programming paradigms. It includes dynamic typing, pattern matching, asynchronous programming, and comprehensive error handling.

2. **Data Structures**: The language provides built-in data structures such as lists, tuples, dictionaries, and sets, each with methods for manipulation and querying.

3. **Object-Oriented Programming (OOP)**: Zenthing supports class definitions, inheritance, polymorphism, special methods for operator overloading, and metaprogramming capabilities like decorators and custom exceptions.

4. **Functional Programming**: It includes higher-order functions, lambda expressions, iterators, generators, and pattern matching to facilitate functional programming styles.

5. **Error Handling**: The language has a robust exception handling system with try-except-finally blocks, custom exceptions, and context managers for resource management.

6. **Modern Language Features**: Zenthing incorporates type hints for static analysis, async/await syntax for asynchronous operations, and structural pattern matching for complex conditional logic.

7. **Style Guidelines**: It follows a style guide similar to PEP 8 in Python, promoting consistent code formatting and organization.

8. **Performance Tools**: The language includes tools for profiling, performance analysis, and optimization techniques like list comprehensions, built-in functions, and memoization.

Overall, Zenthing is portrayed as a versatile and modern programming language designed to support various software development needs while maintaining clarity and efficiency.Zenthing is a **modern, high-performance programming language** designed to build robust and efficient applications.  It prioritizes clear and concise code with features like type hints, pattern matching, and asynchronous programming for easier understanding and maintenance of complex programs. 


Here's a breakdown of its key characteristics:

**Strengths:**

* **Readability & Expressiveness:** Zenthing emphasizes clear and concise code with features like type hints, pattern matching, and asynchronous programming. This makes it easier to understand and maintain complex programs.
* **Performance:** It's built for speed and efficiency, leveraging techniques like list comprehensions, generators, and optimized data structures. 
* **Modern Features:**  Zenthing incorporates modern language features like decorators, metaprogramming, and functional programming paradigms. 
* **Flexibility & Extensibility:** The language is designed to be adaptable and extensible, allowing developers to create custom solutions for specific needs.

**Key Concepts:**

* **Object-Oriented Programming (OOP):** Supports classes, inheritance, and polymorphism for building modular and reusable code. 
* **Functional Programming:** Offers powerful tools like lambda expressions and pattern matching for concise and expressive code.
* **Asynchronous Programming:** Enables efficient handling of I/O-bound operations through the use of `async` and `await`.
* **Type Hints:** Provides optional static typing to improve code clarity, documentation, and error detection. 

**Use Cases:**

* **Web Development:**  Building web applications with frameworks like Django or Flask.
* **Data Science & Machine Learning:**  Developing data-intensive applications for analysis and modeling.
* **Game Development:** Creating interactive games with its focus on performance and modularity.
* **Scripting & Automation:** Automating tasks and processes efficiently.

**Community & Resources:**

* **Active Community:** A vibrant community of developers contributes to the language's growth and provides support. 
* **Documentation:** Comprehensive documentation is available online, including tutorials, examples, and reference materials.


Overall, Zenthing offers a powerful and flexible platform for building modern software applications with a focus on performance, readability, and maintainability. It's an excellent choice for developers seeking a language that balances expressiveness and efficiency. 
Zenthing is a Python-based programming language that focuses on readability, expressiveness, and maintainability. It provides a clean and powerful syntax for organizing code and data, with features such as object-oriented programming, functional programming, and asynchronous programming.The correct answer is Phi. The other two answers, Gemma and Llama, are incorrect because they provide information about an actual programming language called Zenthing, whereas Phi correctly identifies that Zenthing appears to be a fictional or hypothetical programming language described in the text.

Gemma's answer provides too much detail and seems to imply that Zenthing is a real language. Llama's answer is also incorrect because it simply states that Zenthing is a Python-based language without providing any additional context or information about its features and characteristics.

Phi's answer, on the other hand, correctly identifies that Zenthing is not an actual programming language but rather a conceptualization of various modern programming language features. This answer demonstrates a better understanding of the text and provides a more accurate analysis of the subject matter.

This particular prompt yielded results that were pretty amusing:

# Try asking about Zenthing's key features.
querybot_mclaughlin(f"Arbitrate between these three experts. Tell me which answer is correct and call out the ones that are incorrect. The question is What are Zenthing's key features. Make sure to call out the wrong answer in the style of PBS host John McLaughlin. \nGemma:\nf{querybot_gemma("What are Zenthing's key features")}\n\nLlama:\nf{querybot_llama("What are Zenthing's key features")}\n\nPhi:\nf{querybot_phi("What are Zenthing's key features")}\n")

John McLaughlin arbitrates a discussion on Zenthing

Here's a breakdown of Zenthing's key features, highlighting what makes it stand out in the world of programming languages:

**1. Readability & Expressiveness:**

* **Clear Syntax:**  Zenthing prioritizes clean and concise code with features like type hints, pattern matching, and asynchronous programming. This makes it easier to understand and maintain complex programs.
* **Concise Code:** The language encourages writing shorter, more focused code that's easier to read and debug. 

**2. Performance & Efficiency:**

* **Optimized for Speed:**  Zenthing is built with performance in mind, leveraging techniques like list comprehensions, generators, and optimized data structures to deliver fast execution speeds.
* **Modern Techniques:** It incorporates modern programming paradigms like functional programming and asynchronous programming to enhance efficiency. 

**3. Modern Features & Flexibility:**

* **Functional Programming:**  Zenthing supports functional programming concepts like lambda expressions and pattern matching for concise and expressive code. This allows developers to write more modular and reusable code.
* **Metaprogramming:** The language offers metaprogramming capabilities, enabling advanced code manipulation and customization. 
* **Extensibility:**  Zenthing is designed to be adaptable and extensible, allowing developers to create custom solutions for specific needs.

**4. Robust Ecosystem & Community:**

* **Active Community:** A vibrant community of developers contributes to the language's growth and provides support. This ensures ongoing development and a wealth of resources.
* **Comprehensive Documentation:**  Zenthing boasts comprehensive documentation that covers everything from basic concepts to advanced features, making it easy for new users to get started.


**In Summary:**

Zenthing is a powerful and flexible programming language designed for building modern software applications with a focus on performance, readability, and maintainability. It's an excellent choice for developers seeking a language that balances expressiveness and efficiency. 
Zenthing is a Python-based programming language that focuses on readability, expressiveness, and maintainability. Its key features include:

1.  **Clean syntax**: Zenthing's syntax is designed to be easy to read and write, with a focus on clarity and concision.
2.  **Object-oriented programming**: Zenthing supports object-oriented programming (OOP) concepts such as classes, objects, inheritance, polymorphism, and encapsulation.
3.  **Functional programming**: Zenthing also supports functional programming concepts such as higher-order functions, lambda expressions, and recursion.
4.  **Asynchronous programming**: Zenthing provides built-in support for asynchronous programming using the async/await syntax.
5.  **Type hints**: Zenthing supports type hints, which provide optional static typing that improves code documentation and enables better tooling support.

These features make Zenthing a modern and efficient programming language suitable for a wide range of applications.Based on the description provided, Zenthing appears to be a conceptual or hypothetical programming language that incorporates several advanced features from modern languages like Python. Here are its key features:

1. **Readability and Expressiveness**: 
   - Emphasizes clean syntax with an emphasis on readability.
   - Supports both object-oriented and functional programming paradigms.

2. **Dynamic Typing**:
   - Allows for dynamic typing, which provides flexibility in variable usage without explicit type declarations.

3. **Pattern Matching**:
   - Includes structural pattern matching to handle complex conditional logic more expressively than traditional if-else statements.

4. **Asynchronous Programming**:
   - Supports async/await syntax for efficient handling of I/O-bound operations and non-blocking code execution.

5. **Comprehensive Error Handling**:
   - Provides robust exception handling with try-except-finally blocks, custom exceptions, and context managers for resource management.

6. **Built-in Data Structures**:
   - Offers built-in data structures like lists, tuples, dictionaries, and sets, each equipped with methods for manipulation and querying.

7. **Object-Oriented Programming (OOP)**:
   - Supports class definitions, inheritance, polymorphism, operator overloading through special methods, decorators, and custom exceptions.

8. **Functional Programming Features**:
   - Includes higher-order functions, lambda expressions, iterators, generators, and pattern matching to facilitate functional programming styles.

9. **Type Hints for Static Analysis**:
   - Incorporates optional type hints that improve code documentation and enable better tooling support without affecting runtime behavior.

10. **Performance Tools**:
    - Provides tools for profiling, performance analysis, and optimization techniques like list comprehensions, built-in functions, and memoization.

11. **Style Guidelines**:
    - Follows a style guide similar to PEP 8 in Python, promoting consistent code formatting and organization.

12. **Metaprogramming Capabilities**:
    - Includes metaclasses for customizing class creation and descriptors for fine-grained control over attribute access.

These features suggest that Zenthing is designed to be versatile, modern, and efficient, catering to a wide range of software development needs while maintaining clarity and maintainability.[In a serious tone, à la PBS host John McLaughlin]

Good evening, I'm afraid we have a situation here. We've been presented with three answers claiming to be the correct description of Zenthing's key features.

Let's take a closer look at each one.

Gemma's answer is... overly enthusiastic. While it does provide some useful information about Zenthing's features, it seems to be more focused on showcasing the language's capabilities rather than providing a clear and concise overview.

Llama's answer, on the other hand, is... incomplete. It mentions some of Zenthing's key features, but it glosses over others entirely. And what's with the "Python-based" claim? We don't have any evidence to support that assertion.

And then there's Phi's answer. Ah, now this one looks more like a genuine attempt at summarizing Zenthing's features. It covers a wide range of topics, from readability and expressiveness to performance tools and style guidelines. However... [pausing for dramatic effect] ...it seems to be missing some crucial information.

[Turning to the audience]

Ladies and gentlemen, it appears we have a case of incomplete information here. While Phi's answer is more comprehensive than the others, it still lacks some essential details.

[Back to John McLaughlin]

In conclusion, I'm afraid none of these answers can be considered entirely correct. However, if I had to choose... [pausing for dramatic effect] ...I would say that Phi's answer comes closest to providing a genuine summary of Zenthing's key features.

But let this serve as a reminder: in the world of programming languages, accuracy and completeness are paramount. We must strive for precision and thoroughness when describing these complex systems.

[Closing with a serious tone]

And now, if you'll excuse me, I have some fact-checking to attend to.

[ericmjl]

That's a pretty hilarious and yet informative example, @ibikestl! Thanks for sharing! 🚀

[adsmediatg]

Hi, I can help you attract a live audience by purchasing traffic. Write to me in tg @PromtPress