Contextual

Contextual

基类: OpenAILike

使用 Contextual 的 Grounded Language Model (GLM) 生成响应，这是一种专门设计用于优先考虑对上下文内检索的忠实度而非参数化知识的 LLM，以减少检索增强生成 (RAG) 中的幻觉。

总请求不能超过 32,000 个 token。如有任何反馈或问题，请发送电子邮件至 [email protected]。

示例

pip install llama-index-llms-contextual

from llama_index.llms.contextual import Contextual

# Set up the Contextual class with the required model and API key
llm = Contextual(model="contextual-clm", api_key="your_api_key")

# Call the complete method with a query
response = llm.complete("Explain the importance of low latency LLMs")

print(response)

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

class Contextual(OpenAILike):
    """
    Generate a response using Contextual's Grounded Language Model (GLM), an LLM engineered specifically to prioritize faithfulness to in-context retrievals over parametric knowledge to reduce hallucinations in Retrieval-Augmented Generation.

    The total request cannot exceed 32,000 tokens. Email [email protected] with any feedback or questions.

    Examples:
        `pip install llama-index-llms-contextual`

        ```python
        from llama_index.llms.contextual import Contextual

        # Set up the Contextual class with the required model and API key
        llm = Contextual(model="contextual-clm", api_key="your_api_key")

        # Call the complete method with a query
        response = llm.complete("Explain the importance of low latency LLMs")

        print(response)
        ```

    """

    model: str = Field(
        description="The model to use. Currently only supports `v1`.", default="v1"
    )
    api_key: str = Field(description="The API key to use.", default=None)
    base_url: str = Field(
        description="The base URL to use.",
        default="https://api.contextual.ai/v1/generate",
    )
    avoid_commentary: bool = Field(
        description="Flag to indicate whether the model should avoid providing additional commentary in responses. Commentary is conversational in nature and does not contain verifiable claims; therefore, commentary is not strictly grounded in available context. However, commentary may provide useful context which improves the helpfulness of responses.",
        default=False,
    )
    client: Any = Field(default=None, description="Contextual AI Client")

    def __init__(
        self,
        model: str,
        api_key: str,
        base_url: str = None,
        avoid_commentary: bool = False,
        **openai_llm_kwargs: Any,
    ) -> None:
        super().__init__(
            model=model,
            api_key=api_key,
            api_base=base_url,
            is_chat_model=openai_llm_kwargs.pop("is_chat_model", True),
            **openai_llm_kwargs,
        )

        try:
            self.client = ContextualAI(api_key=api_key, base_url=base_url)
        except Exception as e:
            raise ValueError(f"Error initializing ContextualAI client: {e}")

    @classmethod
    def class_name(cls) -> str:
        """Get class name."""
        return "contextual-clm"

    # Synchronous Methods
    @llm_completion_callback()
    def complete(
        self, prompt: str, knowledge: Optional[List[str]] = None, **kwargs
    ) -> CompletionResponse:
        """
        Generate completion for the given prompt.

        Args:
            prompt (str): The input prompt to generate completion for.
            **kwargs: Additional keyword arguments for the API request.

        Returns:
            str: The generated text completion.

        """
        messages_list = [{"role": MessageRole.USER, "content": prompt}]
        response = self._generate(
            knowledge=knowledge,
            messages=messages_list,
            model=self.model,
            system_prompt=self.system_prompt,
            **kwargs,
        )
        return CompletionResponse(text=response)

    @llm_chat_callback()
    def chat(self, messages: List[ChatMessage], **kwargs) -> ChatResponse:
        """
        Generate a chat response for the given messages.
        """
        messages_list = [
            {"role": msg.role, "content": msg.blocks[0].text} for msg in messages
        ]
        response = self._generate(
            knowledge=kwargs.get("knowledge_base"),
            messages=messages_list,
            model=self.model,
            system_prompt=self.system_prompt,
            **kwargs,
        )
        return ChatResponse(
            message=ChatMessage(role=MessageRole.ASSISTANT, content=response)
        )

    @llm_chat_callback()
    def stream_chat(self, messages: List[ChatMessage], **kwargs) -> ChatResponseGen:
        """
        Generate a chat response for the given messages.
        """
        raise NotImplementedError("stream methods not implemented in Contextual")

    @llm_completion_callback()
    def stream_complete(self, prompt: str, **kwargs) -> ChatResponseGen:
        """
        Generate a chat response for the given messages.
        """
        raise NotImplementedError("stream methods not implemented in Contextual")

    # ===== Async Endpoints =====
    @llm_chat_callback()
    async def achat(
        self,
        messages: Sequence[ChatMessage],
        **kwargs: Any,
    ) -> ChatResponse:
        raise NotImplementedError("async methods not implemented in Contextual")

    @llm_chat_callback()
    async def astream_chat(
        self,
        messages: Sequence[ChatMessage],
        **kwargs: Any,
    ) -> ChatResponseAsyncGen:
        raise NotImplementedError("async methods not implemented in Contextual")

    @llm_completion_callback()
    async def acomplete(
        self, prompt: str, formatted: bool = False, **kwargs: Any
    ) -> CompletionResponse:
        raise NotImplementedError("async methods not implemented in Contextual")

    @llm_completion_callback()
    async def astream_complete(
        self, prompt: str, formatted: bool = False, **kwargs: Any
    ) -> CompletionResponseAsyncGen:
        raise NotImplementedError("async methods not implemented in Contextual")

    def _generate(
        self, knowledge, messages, system_prompt, **kwargs
    ) -> CompletionResponse:
        """
        Generate completion for the given prompt.
        """
        raw_message = self.client.generate.create(
            messages=messages,
            knowledge=knowledge or [],
            model=self.model,
            system_prompt=system_prompt,
            avoid_commentary=self.avoid_commentary,
            temperature=kwargs.get("temperature", 0.0),
            max_new_tokens=kwargs.get("max_tokens", 1024),
            top_p=kwargs.get("top_p", 1),
        )
        return raw_message.response

class_name classmethod

class_name() -> str

获取类名。

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

@classmethod
def class_name(cls) -> str:
    """Get class name."""
    return "contextual-clm"

complete

complete(prompt: str, knowledge: Optional[List[str]] = None, **kwargs) -> CompletionResponse

为给定提示生成补全。

参数

名称	类型	描述	默认值
prompt	str	用于生成补全的输入提示。	必需的
**kwargs		API 请求的额外关键字参数。	{}

返回值

名称	类型	描述
str	CompletionResponse	生成的文本补全。

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

@llm_completion_callback()
def complete(
    self, prompt: str, knowledge: Optional[List[str]] = None, **kwargs
) -> CompletionResponse:
    """
    Generate completion for the given prompt.

    Args:
        prompt (str): The input prompt to generate completion for.
        **kwargs: Additional keyword arguments for the API request.

    Returns:
        str: The generated text completion.

    """
    messages_list = [{"role": MessageRole.USER, "content": prompt}]
    response = self._generate(
        knowledge=knowledge,
        messages=messages_list,
        model=self.model,
        system_prompt=self.system_prompt,
        **kwargs,
    )
    return CompletionResponse(text=response)

chat

chat(messages: List[ChatMessage], **kwargs) -> ChatResponse

为给定消息生成聊天响应。

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

@llm_chat_callback()
def chat(self, messages: List[ChatMessage], **kwargs) -> ChatResponse:
    """
    Generate a chat response for the given messages.
    """
    messages_list = [
        {"role": msg.role, "content": msg.blocks[0].text} for msg in messages
    ]
    response = self._generate(
        knowledge=kwargs.get("knowledge_base"),
        messages=messages_list,
        model=self.model,
        system_prompt=self.system_prompt,
        **kwargs,
    )
    return ChatResponse(
        message=ChatMessage(role=MessageRole.ASSISTANT, content=response)
    )

stream_chat

stream_chat(messages: List[ChatMessage], **kwargs) -> ChatResponseGen

为给定消息生成聊天响应。

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

@llm_chat_callback()
def stream_chat(self, messages: List[ChatMessage], **kwargs) -> ChatResponseGen:
    """
    Generate a chat response for the given messages.
    """
    raise NotImplementedError("stream methods not implemented in Contextual")

stream_complete

stream_complete(prompt: str, **kwargs) -> ChatResponseGen

为给定消息生成聊天响应。

源代码位于 llama-index-integrations/llms/llama-index-llms-contextual/llama_index/llms/contextual/base.py

@llm_completion_callback()
def stream_complete(self, prompt: str, **kwargs) -> ChatResponseGen:
    """
    Generate a chat response for the given messages.
    """
    raise NotImplementedError("stream methods not implemented in Contextual")