Update README.md

README.md

@@ -125,11 +125,12 @@ Now you can start a new conversation with the agent by clicking on the plus sign
 
 
 The model can also be deployed with the following libraries:
-- [`LMStudio (recommended for quantized model)`](https://lmstudio.ai/): See [here](#lmstudio)
-- [`vllm (recommended)`](https://github.com/vllm-project/vllm): See [here](#vllm)
-- [`ollama`](https://github.com/ollama/ollama): See [here](#ollama)
+- [`LMStudio (recommended for quantized model)`](https://lmstudio.ai/): See [here](#lmstudio-recommended-for-quantized-model)
+- [`vllm (recommended)`](https://github.com/vllm-project/vllm): See [here](#vllm-recommended)
 - [`mistral-inference`](https://github.com/mistralai/mistral-inference): See [here](#mistral-inference)
 - [`transformers`](https://github.com/huggingface/transformers): See [here](#transformers)
+- [`ollama`](https://github.com/ollama/ollama): See [here](#ollama)
+
 
 ### OpenHands (recommended)
 
@@ -267,7 +268,7 @@ Make sure you install [`vLLM >= 0.8.5`](https://github.com/vllm-project/vllm/rel
 pip install vllm --upgrade
 ```
 
-Doing so should automatically install [`mistral_common >= 1.5.4`](https://github.com/mistralai/mistral-common/releases/tag/v1.5.4).
+Doing so should automatically install [`mistral_common >= 1.5.5`](https://github.com/mistralai/mistral-common/releases/tag/v1.5.5).
 
 To check:
 ```
@@ -315,7 +316,7 @@ messages = [
         "content": [
             {
                 "type": "text",
-                "text": "Write a function that computes fibonacci in Python.",
+                "text": "<your-command>",
             },
         ],
     },
@@ -327,96 +328,6 @@ response = requests.post(url, headers=headers, data=json.dumps(data))
 print(response.json()["choices"][0]["message"]["content"])
 ```
 
-<details>
-    <summary>Output</summary>
-    
-Certainly! The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, usually starting with 0 and 1. Here's a simple Python function to compute the Fibonacci sequence:
-
-### Iterative Approach
-This approach uses a loop to compute the Fibonacci number iteratively.
-
-```python
-def fibonacci(n):
-    if n <= 0:
-        return "Input should be a positive integer."
-    elif n == 1:
-        return 0
-    elif n == 2:
-        return 1
-
-    a, b = 0, 1
-    for _ in range(2, n):
-        a, b = b, a + b
-    return b
-
-# Example usage:
-print(fibonacci(10))  # Output: 34
-```
-
-### Recursive Approach
-This approach uses recursion to compute the Fibonacci number. Note that this is less efficient for large `n` due to repeated calculations.
-
-```python
-def fibonacci_recursive(n):
-    if n <= 0:
-        return "Input should be a positive integer."
-    elif n == 1:
-        return 0
-    elif n == 2:
-        return 1
-    else:
-        return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
-
-# Example usage:
-print(fibonacci_recursive(10))  # Output: 34
-```
-
-\### Memoization Approach
-This approach uses memoization to store previously computed Fibonacci numbers, making it more efficient than the simple recursive approach.
-
-```python
-def fibonacci_memo(n, memo={}):
-    if n <= 0:
-        return "Input should be a positive integer."
-    elif n == 1:
-        return 0
-    elif n == 2:
-        return 1
-    elif n in memo:
-        return memo[n]
-
-    memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
-    return memo[n]
-
-# Example usage:
-print(fibonacci_memo(10))  # Output: 34
-```
-
-\### Dynamic Programming Approach
-This approach uses an array to store the Fibonacci numbers up to `n`.
-
-```python
-def fibonacci_dp(n):
-    if n <= 0:
-        return "Input should be a positive integer."
-    elif n == 1:
-        return 0
-    elif n == 2:
-        return 1
-
-    fib = [0, 1] + [0] * (n - 2)
-    for i in range(2, n):
-        fib[i] = fib[i - 1] + fib[i - 2]
-    return fib[n - 1]
-
-# Example usage:
-print(fibonacci_dp(10))  # Output: 34
-```
-
-You can choose any of these approaches based on your needs. The iterative and dynamic programming approaches are generally more efficient for larger values of `n`.
-
-</details>
-
 
 ### Mistral-inference
 
@@ -450,39 +361,7 @@ You can run the model using the following command:
 mistral-chat $HOME/mistral_models/Devstral --instruct --max_tokens 300
 ```
 
-If you prompt it with "Write me a unique and efficient function that computes fibonacci in Python", the model should generate something along the following lines:
-
-<details>
-  <summary>Output</summary>
-
-Certainly! A common and efficient way to compute Fibonacci numbers is by using memoization to store previously computed values. This avoids redundant calculations and significantly improves performance. Below is a Python function that uses memoization to compute Fibonacci numbers efficiently:
-
-```python
-def fibonacci(n, memo=None):
-    if memo is None:
-        memo = {}
-
-    if n in memo:
-        return memo[n]
-
-    if n <= 1:
-        return n
-
-    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
-    return memo[n]
-
-# Example usage:
-n = 10
-print(f"Fibonacci number at position {n} is {fibonacci(n)}")
-```
-
-### Explanation:
-
-1. **Base Case**: If `n` is 0 or 1, the function returns `n` because the Fibonacci sequence starts with 0 and 1.
-2. **Memoization**: The function uses a dictionary `memo` to store the results of previously computed Fibonacci numbers.
-3. **Recursive Case**: For other values of `n`, the function recursively computes the Fibonacci number by summing the results of `fibonacci(n - 1)` and `fibonacci(n)`
-
-</details>
+You can then prompt it with anything you'd like.
 
 ### Ollama
 
@@ -532,7 +411,7 @@ tokenized = tokenizer.encode_chat_completion(
     ChatCompletionRequest(
         messages=[
             SystemMessage(content=SYSTEM_PROMPT),
-            UserMessage(content="Write me a function that computes fibonacci in Python."),
+            UserMessage(content="<your-command>"),
         ],
     )
 )