Improved context precision documentation (#2266)

## Issue Link / Problem Description
<!-- Link to related issue or describe the problem this PR solves -->
- Fixes #[issue_number]
- OR describe the issue: What problem does this solve? How can it be
replicated

The existing documentation has a mistake, and in some cases, poor style
and grammar or is missing key information.

## Changes Made
<!-- Describe what you changed and why -->
- Provided separate example for explaining Context Precision as a metric
- Corrected the definition of the metric
LLMContextPrecisionWithoutReference
- Improved Grammar and style
- For NonLLMContextPrecisionWithReference, added packages to be
installed and also included an example of the distance algorithm used

---
<!-- 
Thank you for contributing to Ragas! 
Please fill out the sections above as completely as possible.
The more information you provide, the faster your PR can be reviewed and
merged.
-->

Author: anupamck

docs/concepts/metrics/available_metrics/context_precision.md

@@ -13,14 +13,6 @@ $$
 
 Where $K$ is the total number of chunks in `retrieved_contexts` and $v_k \in \{0, 1\}$ is the relevance indicator at rank $k$.
 
-## LLM Based Context Precision
-
-The following metrics uses LLM to identify if a retrieved context is relevant or not.
-
-### Context Precision without reference
-
-`LLMContextPrecisionWithoutReference` metric can be used when you have both retrieved contexts and also reference answer associated with a `user_input`. To estimate if a retrieved contexts is relevant or not this method uses the LLM to compare each of the retrieved context or chunk present in `retrieved_contexts` with `response`.
-
 #### Example
 
 ```python
@@ -87,9 +79,38 @@ Output
 0.49999999995
 ```
 
+## LLM Based Context Precision
+
+The following metrics uses LLM to identify if a retrieved context is relevant or not.
+
+### Context Precision without reference
+
+The `LLMContextPrecisionWithoutReference` metric can be used without the availability of a reference answer. To estimate if the retrieved contexts are relevant, this method uses the LLM to compare each chunk in `retrieved_contexts` with the `response`.
+
+#### Example
+    
+```python
+from ragas import SingleTurnSample
+from ragas.metrics import LLMContextPrecisionWithoutReference
+
+context_precision = LLMContextPrecisionWithoutReference(llm=evaluator_llm)
+
+sample = SingleTurnSample(
+    user_input="Where is the Eiffel Tower located?",
+    response="The Eiffel Tower is located in Paris.",
+    retrieved_contexts=["The Eiffel Tower is located in Paris."], 
+)
+
+
+await context_precision.single_turn_ascore(sample)
+```
+Output
+```
+0.9999999999
+```
 ### Context Precision with reference
 
-`LLMContextPrecisionWithReference` metric is can be used when you have both retrieved contexts and also reference context associated with a `user_input`. To estimate if a retrieved contexts is relevant or not this method uses the LLM to compare each of the retrieved context or chunk present in `retrieved_contexts` with `reference`. 
+The `LLMContextPrecisionWithReference` metric can be used when you have both retrieved contexts and also a reference response associated with a `user_input`. To estimate if the retrieved contexts are relevant, this method uses the LLM to compare each chunk in `retrieved_contexts` with the `reference`.
 
 #### Example
 
@@ -114,12 +135,14 @@ Output
 
 ## Non LLM Based Context Precision
 
-This metric uses traditional methods to determine whether a retrieved context is relevant. It relies on non-LLM-based metrics as a distance measure to evaluate the relevance of retrieved contexts.
+This metric uses non-LLM-based methods (such as [Levenshtein distance measure](https://en.wikipedia.org/wiki/Levenshtein_distance)) to determine whether a retrieved context is relevant.
 
 ### Context Precision with reference contexts
 
 The `NonLLMContextPrecisionWithReference` metric is designed for scenarios where both retrieved contexts and reference contexts are available for a `user_input`. To determine if a retrieved context is relevant, this method compares each retrieved context or chunk in `retrieved_contexts` with every context in `reference_contexts` using a non-LLM-based similarity measure.
 
+Note that this metric would need the rapidfuzz package to be installed: `pip install rapidfuzz`. 
+
 #### Example
 
 ```python