fix: add support for both langchain llm and ragas llm (#2229)

## Issue Link / Problem Description
<!-- Link to related issue or describe the problem this PR solves -->
- Fixes #2085 

## Changes Made
<!-- Describe what you changed and why -->
- Handle both LangChain LLMs and Ragas LLMs.

Author: anistark

.gitignore

@@ -169,6 +169,7 @@ _experiments/
 **/fil-result/
 src/ragas/_version.py
 experimental/ragas_experimental/_version.py
+examples/ragas_examples/_version.py
 .vscode
 .envrc
 uv.lock

src/ragas/prompt/multi_modal_prompt.py

@@ -12,24 +12,44 @@
 from urllib.parse import urlparse
 
 import requests
+from langchain_core.language_models import BaseLanguageModel
 from langchain_core.messages import BaseMessage, HumanMessage
 from langchain_core.prompt_values import PromptValue
 from PIL import Image
 from pydantic import BaseModel
+from typing_extensions import TypedDict
 
 from ragas.callbacks import ChainType, new_group
 from ragas.exceptions import RagasOutputParserException
-from ragas.prompt.pydantic_prompt import PydanticPrompt, RagasOutputParser
+from ragas.prompt.pydantic_prompt import (
+    PydanticPrompt,
+    RagasOutputParser,
+    is_langchain_llm,
+)
 
 if t.TYPE_CHECKING:
     from langchain_core.callbacks import Callbacks
 
-    from ragas.llms.base import BaseRagasLLM
+from ragas.llms.base import BaseRagasLLM
 
 # type variables for input and output models
 InputModel = t.TypeVar("InputModel", bound=BaseModel)
 OutputModel = t.TypeVar("OutputModel", bound=BaseModel)
 
+
+# Specific typed dictionaries for message content
+class TextContent(TypedDict):
+    type: t.Literal["text"]
+    text: str
+
+
+class ImageUrlContent(TypedDict):
+    type: t.Literal["image_url"]
+    image_url: dict[str, str]
+
+
+MessageContent = t.Union[TextContent, ImageUrlContent]
+
 logger = logging.getLogger(__name__)
 
 # --- Constants for Security Policy ---
@@ -101,7 +121,7 @@ def to_prompt_value(self, data: t.Optional[InputModel] = None):
 
     async def generate_multiple(
         self,
-        llm: BaseRagasLLM,
+        llm: t.Union[BaseRagasLLM, BaseLanguageModel],
         data: InputModel,
         n: int = 1,
         temperature: t.Optional[float] = None,
@@ -146,26 +166,47 @@ async def generate_multiple(
             metadata={"type": ChainType.RAGAS_PROMPT},
         )
         prompt_value = self.to_prompt_value(processed_data)
-        resp = await llm.generate(
-            prompt_value,
-            n=n,
-            temperature=temperature,
-            stop=stop,
-            callbacks=prompt_cb,
-        )
+
+        # Handle both LangChain LLMs and Ragas LLMs
+        # LangChain LLMs have agenerate() for async, generate() for sync
+        # Ragas LLMs have generate() as async method
+        if is_langchain_llm(llm):
+            # This is a LangChain LLM - use agenerate_prompt()
+            langchain_llm = t.cast(BaseLanguageModel, llm)
+            resp = await langchain_llm.agenerate_prompt(
+                [prompt_value],
+                stop=stop,
+                callbacks=prompt_cb,
+            )
+        else:
+            # This is a Ragas LLM - use generate()
+            ragas_llm = t.cast(BaseRagasLLM, llm)
+            resp = await ragas_llm.generate(
+                prompt_value,
+                n=n,
+                temperature=temperature,
+                stop=stop,
+                callbacks=prompt_cb,
+            )
 
         output_models = []
         parser = RagasOutputParser(pydantic_object=self.output_model)  # type: ignore
         for i in range(n):
             output_string = resp.generations[0][i].text
             try:
-                answer = await parser.parse_output_string(
-                    output_string=output_string,
-                    prompt_value=prompt_value,  # type: ignore
-                    llm=llm,
-                    callbacks=prompt_cb,
-                    retries_left=retries_left,
-                )
+                # For the parser, we need a BaseRagasLLM, so if it's a LangChain LLM, we need to handle this
+                if is_langchain_llm(llm):
+                    # Skip parsing retry for LangChain LLMs since parser expects BaseRagasLLM
+                    answer = self.output_model.model_validate_json(output_string)
+                else:
+                    ragas_llm = t.cast(BaseRagasLLM, llm)
+                    answer = await parser.parse_output_string(
+                        output_string=output_string,
+                        prompt_value=prompt_value,  # type: ignore
+                        llm=ragas_llm,
+                        callbacks=prompt_cb,
+                        retries_left=retries_left,
+                    )
                 processed_output = self.process_output(answer, data)  # type: ignore
                 output_models.append(processed_output)
             except RagasOutputParserException as e:
@@ -204,7 +245,7 @@ def to_messages(self) -> t.List[BaseMessage]:
             # Return empty list or handle as appropriate if all items failed processing
             return []
 
-    def _securely_process_item(self, item: str) -> t.Optional[t.Dict[str, t.Any]]:
+    def _securely_process_item(self, item: str) -> t.Optional[MessageContent]:
         """
         Securely determines if an item is text, a valid image data URI,
         or a fetchable image URL according to policy. Returns the appropriate
@@ -258,11 +299,11 @@ def _looks_like_image_path(self, item: str) -> bool:
         _, ext = os.path.splitext(path_part)
         return ext.lower() in COMMON_IMAGE_EXTENSIONS
 
-    def _get_text_payload(self, text: str) -> dict:
+    def _get_text_payload(self, text: str) -> TextContent:
         """Returns the standard payload for text content."""
         return {"type": "text", "text": text}
 
-    def _get_image_payload(self, mime_type: str, encoded_image: str) -> dict:
+    def _get_image_payload(self, mime_type: str, encoded_image: str) -> ImageUrlContent:
         """Returns the standard payload for image content."""
         # Ensure mime_type is safe and starts with "image/"
         if not mime_type or not mime_type.lower().startswith("image/"):

src/ragas/prompt/pydantic_prompt.py

@@ -8,6 +8,7 @@
 import typing as t
 
 from langchain_core.exceptions import OutputParserException
+from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import PydanticOutputParser
 from langchain_core.prompt_values import StringPromptValue as PromptValue
 from pydantic import BaseModel
@@ -22,7 +23,21 @@
 if t.TYPE_CHECKING:
     from langchain_core.callbacks import Callbacks
 
-    from ragas.llms.base import BaseRagasLLM
+from ragas.llms.base import BaseRagasLLM
+
+
+def is_langchain_llm(llm: t.Union[BaseRagasLLM, BaseLanguageModel]) -> bool:
+    """
+    Detect if an LLM is a LangChain LLM or a Ragas LLM.
+
+    Args:
+        llm: The LLM instance to check
+
+    Returns:
+        True if it's a LangChain LLM, False if it's a Ragas LLM
+    """
+    return hasattr(llm, "agenerate") and not hasattr(llm, "run_config")
+
 
 logger = logging.getLogger(__name__)
 
@@ -87,7 +102,7 @@ def to_string(self, data: t.Optional[InputModel] = None) -> str:
 
     async def generate(
         self,
-        llm: BaseRagasLLM,
+        llm: t.Union[BaseRagasLLM, BaseLanguageModel],
         data: InputModel,
         temperature: t.Optional[float] = None,
         stop: t.Optional[t.List[str]] = None,
@@ -139,7 +154,7 @@ async def generate(
 
     async def generate_multiple(
         self,
-        llm: BaseRagasLLM,
+        llm: t.Union[BaseRagasLLM, BaseLanguageModel],
         data: InputModel,
         n: int = 1,
         temperature: t.Optional[float] = None,
@@ -187,26 +202,47 @@ async def generate_multiple(
             metadata={"type": ChainType.RAGAS_PROMPT},
         )
         prompt_value = PromptValue(text=self.to_string(processed_data))
-        resp = await llm.generate(
-            prompt_value,
-            n=n,
-            temperature=temperature,
-            stop=stop,
-            callbacks=prompt_cb,
-        )
+
+        # Handle both LangChain LLMs and Ragas LLMs
+        # LangChain LLMs have agenerate() for async, generate() for sync
+        # Ragas LLMs have generate() as async method
+        if is_langchain_llm(llm):
+            # This is a LangChain LLM - use agenerate_prompt()
+            langchain_llm = t.cast(BaseLanguageModel, llm)
+            resp = await langchain_llm.agenerate_prompt(
+                [prompt_value],
+                stop=stop,
+                callbacks=prompt_cb,
+            )
+        else:
+            # This is a Ragas LLM - use generate()
+            ragas_llm = t.cast(BaseRagasLLM, llm)
+            resp = await ragas_llm.generate(
+                prompt_value,
+                n=n,
+                temperature=temperature,
+                stop=stop,
+                callbacks=prompt_cb,
+            )
 
         output_models = []
         parser = RagasOutputParser(pydantic_object=self.output_model)
         for i in range(n):
             output_string = resp.generations[0][i].text
             try:
-                answer = await parser.parse_output_string(
-                    output_string=output_string,
-                    prompt_value=prompt_value,
-                    llm=llm,
-                    callbacks=prompt_cb,
-                    retries_left=retries_left,
-                )
+                # For the parser, we need a BaseRagasLLM, so if it's a LangChain LLM, we need to handle this
+                if is_langchain_llm(llm):
+                    # Skip parsing retry for LangChain LLMs since parser expects BaseRagasLLM
+                    answer = self.output_model.model_validate_json(output_string)
+                else:
+                    ragas_llm = t.cast(BaseRagasLLM, llm)
+                    answer = await parser.parse_output_string(
+                        output_string=output_string,
+                        prompt_value=prompt_value,
+                        llm=ragas_llm,
+                        callbacks=prompt_cb,
+                        retries_left=retries_left,
+                    )
                 processed_output = self.process_output(answer, data)  # type: ignore
                 output_models.append(processed_output)
             except RagasOutputParserException as e: