langchain-dev-utils 0.1.0__py3-none-any.whl

langchain_dev_utils/__init__.py

@@ -0,0 +1,24 @@
+from .has_tool_calling import has_tool_calling
+from .content import (
+    convert_reasoning_content_for_ai_message,
+    convert_reasoning_content_for_chunk_iterator,
+    aconvert_reasoning_content_for_ai_message,
+    aconvert_reasoning_content_for_chunk_iterator,
+)
+from .embbedings import load_embeddings, register_embeddings_provider
+from .chat_model import load_chat_model, register_model_provider
+
+__all__ = [
+    "has_tool_calling",
+    "convert_reasoning_content_for_ai_message",
+    "convert_reasoning_content_for_chunk_iterator",
+    "aconvert_reasoning_content_for_ai_message",
+    "aconvert_reasoning_content_for_chunk_iterator",
+    "load_embeddings",
+    "register_embeddings_provider",
+    "load_chat_model",
+    "register_model_provider",
+]
+
+
+__version__ = "0.1.0"

langchain_dev_utils/chat_model.py

@@ -0,0 +1,136 @@
+import os
+from typing import Any, Optional, Union, cast
+
+from langchain.chat_models.base import (
+    BaseChatModel,
+    _SUPPORTED_PROVIDERS,
+    init_chat_model,
+    _init_chat_model_helper,
+)
+
+
+_MODEL_PROVIDERS_DICT = {}
+
+
+def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
+    """Parse model string and provider.
+    
+    Args:
+        model: Model name string, potentially including provider prefix
+        model_provider: Optional provider name
+        
+    Returns:
+        Tuple of (model_name, provider_name)
+        
+    Raises:
+        ValueError: If unable to infer model provider
+    """
+    if (
+        not model_provider
+        and ":" in model
+        and model.split(":")[0] in _MODEL_PROVIDERS_DICT
+    ):
+        model_provider = model.split(":")[0]
+        model = ":".join(model.split(":")[1:])
+    if not model_provider:
+        msg = (
+            f"Unable to infer model provider for {model=}, please specify "
+            f"model_provider directly."
+        )
+        raise ValueError(msg)
+    model_provider = model_provider.replace("-", "_").lower()
+    return model, model_provider
+
+
+def _load_chat_model_helper(
+    model: str,
+    model_provider: Optional[str] = None,
+    **kwargs: Any,
+) -> BaseChatModel:
+    """Helper function to load chat model.
+    
+    Args:
+        model: Model name
+        model_provider: Optional provider name
+        **kwargs: Additional arguments for model initialization
+        
+    Returns:
+        BaseChatModel: Initialized chat model instance
+    """
+    model, model_provider = _parse_model(model, model_provider)
+    if model_provider in _MODEL_PROVIDERS_DICT.keys():
+        chat_model = _MODEL_PROVIDERS_DICT[model_provider]["chat_model"]
+        if isinstance(chat_model, str):
+            if not (api_key := kwargs.get("api_key")):
+                api_key = os.getenv(f"{model_provider.upper()}_API_KEY")
+                if not api_key:
+                    raise ValueError(
+                        f"API key for {model_provider} not found. Please set it in the environment."
+                    )
+                kwargs["api_key"] = api_key
+            base_url = _MODEL_PROVIDERS_DICT[model_provider]["base_url"]
+            return init_chat_model(
+                model=model,
+                model_provider=chat_model,
+                base_url=base_url,
+                **kwargs,
+            )
+        else:
+            return chat_model(model=model, **kwargs)
+
+    return _init_chat_model_helper(model, model_provider=model_provider, **kwargs)
+
+
+def register_model_provider(
+    provider_name: str,
+    chat_model: Union[type[BaseChatModel], str],
+    base_url: Optional[str] = None,
+):
+    """Register a new model provider.
+    
+    Args:
+        provider_name: Name of the provider to register
+        chat_model: Either a BaseChatModel class or a string identifier for a supported provider
+        base_url: Optional base URL for API endpoints (required when chat_model is a string)
+        
+    Raises:
+        ValueError: If base_url is not provided when chat_model is a string,
+                   or if chat_model string is not in supported providers
+    """
+    if isinstance(chat_model, str):
+        if base_url is None:
+            raise ValueError("base_url must be provided when chat_model is a string")
+
+        if chat_model not in _SUPPORTED_PROVIDERS:
+            raise ValueError(
+                f"when chat_model is a string, the value must be one of {_SUPPORTED_PROVIDERS}"
+            )
+
+        _MODEL_PROVIDERS_DICT.update(
+            {provider_name: {"chat_model": chat_model, "base_url": base_url}}
+        )
+    else:
+        _MODEL_PROVIDERS_DICT.update({provider_name: {"chat_model": chat_model}})
+
+
+def load_chat_model(
+    model: Optional[str] = None,
+    *,
+    model_provider: Optional[str] = None,
+    **kwargs: Any,
+) -> BaseChatModel:
+    """Load a chat model.
+    
+    Args:
+        model: Model name
+        model_provider: Optional provider name
+        **kwargs: Additional arguments for model initialization
+        
+    Returns:
+        BaseChatModel: Initialized chat model instance
+    """
+    return _load_chat_model_helper(
+        cast(str, model),
+        model_provider=model_provider,
+        **kwargs,
+    )

langchain_dev_utils/content.py

@@ -0,0 +1,121 @@
+from typing import AsyncIterator, Iterator, Tuple
+
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessageChunk,
+)
+
+
+def convert_reasoning_content_for_ai_message(
+    model_response: AIMessage,
+    think_tag: Tuple[str, str] = ("", ""),
+) -> AIMessage:
+    """Convert reasoning content in AI message to visible content.
+    
+    Args:
+        model_response: AI message response from model
+        think_tag: Tuple of (opening_tag, closing_tag) to wrap reasoning content
+        
+    Returns:
+        AIMessage: Modified AI message with reasoning content in visible content
+    """
+    if "reasoning_content" in model_response.additional_kwargs:
+        model_response.content = f"{think_tag[0]}{model_response.additional_kwargs['reasoning_content']}{think_tag[1]}"
+    return model_response
+
+
+def convert_reasoning_content_for_chunk_iterator(
+    model_response: Iterator[BaseMessageChunk],
+    think_tag: Tuple[str, str] = ("", ""),
+) -> Iterator[BaseMessageChunk]:
+    """Convert reasoning content for streaming response chunks.
+    
+    Args:
+        model_response: Iterator of message chunks from streaming response
+        think_tag: Tuple of (opening_tag, closing_tag) to wrap reasoning content
+        
+    Yields:
+        BaseMessageChunk: Modified message chunks with reasoning content
+    """
+    isfirst = True
+    isend = True
+
+    for chunk in model_response:
+        if (
+            isinstance(chunk, AIMessageChunk)
+            and "reasoning_content" in chunk.additional_kwargs
+        ):
+            if isfirst:
+                chunk.content = (
+                    f"{think_tag[0]}{chunk.additional_kwargs['reasoning_content']}"
+                )
+                isfirst = False
+            else:
+                chunk.content = chunk.additional_kwargs["reasoning_content"]
+        elif (
+            isinstance(chunk, AIMessageChunk)
+            and "reasoning_content" not in chunk.additional_kwargs
+            and chunk.content
+            and isend
+        ):
+            chunk.content = f"{think_tag[1]}{chunk.content}"
+            isend = False
+        yield chunk
+
+
+async def aconvert_reasoning_content_for_ai_message(
+    model_response: AIMessage,
+    think_tag: Tuple[str, str] = ("", ""),
+) -> AIMessage:
+    """Async convert reasoning content in AI message to visible content.
+    
+    Args:
+        model_response: AI message response from model
+        think_tag: Tuple of (opening_tag, closing_tag) to wrap reasoning content
+        
+    Returns:
+        AIMessage: Modified AI message with reasoning content in visible content
+    """
+    if "reasoning_content" in model_response.additional_kwargs:
+        model_response.content = f"{think_tag[0]}{model_response.additional_kwargs['reasoning_content']}{think_tag[1]}"
+    return model_response
+
+
+async def aconvert_reasoning_content_for_chunk_iterator(
+    amodel_response: AsyncIterator[BaseMessageChunk],
+    think_tag: Tuple[str, str] = ("", ""),
+) -> AsyncIterator[BaseMessageChunk]:
+    """Async convert reasoning content for streaming response chunks.
+    
+    Args:
+        amodel_response: Async iterator of message chunks from streaming response
+        think_tag: Tuple of (opening_tag, closing_tag) to wrap reasoning content
+        
+    Yields:
+        BaseMessageChunk: Modified message chunks with reasoning content
+    """
+    isfirst = True
+    isend = True
+
+    async for chunk in amodel_response:
+        if (
+            isinstance(chunk, AIMessageChunk)
+            and "reasoning_content" in chunk.additional_kwargs
+        ):
+            if isfirst:
+                chunk.content = (
+                    f"{think_tag[0]}{chunk.additional_kwargs['reasoning_content']}"
+                )
+                isfirst = False
+            else:
+                chunk.content = chunk.additional_kwargs["reasoning_content"]
+        elif (
+            isinstance(chunk, AIMessageChunk)
+            and "reasoning_content" not in chunk.additional_kwargs
+            and chunk.content
+            and isend
+        ):
+            chunk.content = f"{think_tag[1]}{chunk.content}"
+            isend = False
+        yield chunk

langchain_dev_utils/embbedings.py

@@ -0,0 +1,121 @@
+import os
+from typing import Any, Optional, Union
+from langchain.embeddings.base import init_embeddings, _SUPPORTED_PROVIDERS, Embeddings
+from langchain_core.runnables import Runnable
+
+
+_EMBEDDINGS_PROVIDERS_DICT = {}
+
+
+def _parse_model_string(model_name: str) -> tuple[str, str]:
+    """Parse model string into provider and model name.
+    
+    Args:
+        model_name: Model name string in format 'provider:model-name'
+        
+    Returns:
+        Tuple of (provider, model) parsed from the model_name
+        
+    Raises:
+        ValueError: If model name format is invalid or model name is empty
+    """
+    if ":" not in model_name:
+        msg = (
+            f"Invalid model format '{model_name}'.\n"
+            f"Model name must be in format 'provider:model-name'\n"
+        )
+        raise ValueError(msg)
+
+    provider, model = model_name.split(":", 1)
+    provider = provider.lower().strip()
+    model = model.strip()
+    if not model:
+        msg = "Model name cannot be empty"
+        raise ValueError(msg)
+    return provider, model
+
+
+def register_embeddings_provider(
+    provider_name: str,
+    embeddings_model: Union[type[Embeddings], str],
+    base_url: Optional[str] = None,
+):
+    """Register an embeddings provider.
+    
+    Args:
+        provider_name: Name of the provider to register
+        embeddings_model: Either an Embeddings class or a string identifier for a supported provider
+        base_url: Optional base URL for API endpoints (required when embeddings_model is a string)
+        
+    Raises:
+        ValueError: If base_url is not provided when embeddings_model is a string
+    """
+    if isinstance(embeddings_model, str):
+        if base_url is None:
+            raise ValueError(
+                "base_url must be provided when embeddings_model is a string"
+            )
+
+        if embeddings_model not in _SUPPORTED_PROVIDERS:
+            raise ValueError(
+                f"when embeddings_model is a string, the value must be one of {_SUPPORTED_PROVIDERS}"
+            )
+
+        _EMBEDDINGS_PROVIDERS_DICT.update(
+            {
+                provider_name: {
+                    "embeddings_model": embeddings_model,
+                    "base_url": base_url,
+                }
+            }
+        )
+    else:
+        _EMBEDDINGS_PROVIDERS_DICT.update(
+            {provider_name: {"embeddings_model": embeddings_model}}
+        )
+
+
+def load_embeddings(
+    model: str,
+    *,
+    provider: Optional[str] = None,
+    **kwargs: Any,
+) -> Union[Embeddings, Runnable[Any, list[float]]]:
+    """Load embeddings model.
+    
+    Args:
+        model: Model name in format 'provider:model-name' if provider not specified separately
+        provider: Optional provider name (if not included in model parameter)
+        **kwargs: Additional arguments for model initialization
+        
+    Returns:
+        Union[Embeddings, Runnable[Any, list[float]]]: Initialized embeddings model instance
+        
+    Raises:
+        ValueError: If provider is not registered or API key is not found
+    """
+    if provider is None:
+        provider, model = _parse_model_string(model)
+    if provider not in _EMBEDDINGS_PROVIDERS_DICT:
+        raise ValueError(f"Provider {provider} not registered")
+
+    embeddings = _EMBEDDINGS_PROVIDERS_DICT[provider]["embeddings_model"]
+    if isinstance(embeddings, str):
+        if not (api_key := kwargs.get("api_key")):
+            api_key = os.getenv(f"{provider.upper()}_API_KEY")
+            if not api_key:
+                raise ValueError(
+                    f"API key for {provider} not found. Please set it in the environment."
+                )
+            kwargs["api_key"] = api_key
+            if embeddings == "openai":
+                kwargs["check_embedding_ctx_length"] = False
+
+        return init_embeddings(
+            model=model,
+            provider=embeddings,
+            base_url=_EMBEDDINGS_PROVIDERS_DICT[provider]["base_url"],
+            **kwargs,
+        )
+    else:
+        return embeddings(model=model, **kwargs)

langchain_dev_utils/has_tool_calling.py

@@ -0,0 +1,19 @@
+from langchain_core.messages import AIMessage, AnyMessage
+
+
+def has_tool_calling(message: AnyMessage):
+    """Check if a message contains tool calls.
+    
+    Args:
+        message: Any message type to check for tool calls
+        
+    Returns:
+        bool: True if message is an AIMessage with tool calls, False otherwise
+    """
+    if (
+        isinstance(message, AIMessage)
+        and hasattr(message, "tool_calls")
+        and len(message.tool_calls) > 0
+    ):
+        return True
+    return False

langchain_dev_utils-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: langchain-dev-utils
+Version: 0.1.0
+Summary: A practical utility library for LangChain and LangGraph development
+Project-URL: Source Code, https://github.com/TBice123123/langchain-dev-utils
+Project-URL: repository, https://github.com/TBice123123/langchain-dev-utils
+Author-email: tiebingice <tiebingice123@outlook.com>
+Requires-Python: >=3.11
+Requires-Dist: langchain>=0.3.27
+Requires-Dist: langgraph>=0.6.6
+Description-Content-Type: text/markdown
+
+# LangChain Dev Utils
+
+[中文文档](https://github.com/TBice123123/langchain-dev-utils/blob/master/README_cn.md)
+
+This toolkit is designed to provide encapsulated utility tools for developers using LangChain and LangGraph to develop large language model applications, helping developers work more efficiently.
+
+## Installation and Usage
+
+1. Using pip
+
+```bash
+pip install -U langchain-dev-utils
+```
+
+2. Using poetry
+
+```bash
+poetry add langchain-dev-utils
+```
+
+3. Using uv
+
+```bash
+uv add langchain-dev-utils
+```
+
+## Function Modules
+
+### 1. Extended Model Loading Functionality
+
+While the official `init_chat_model` function is very useful, it has limited support for model providers. This toolkit provides extended model loading functionality that allows registration and use of more model providers.
+
+#### Core Functions
+
+- `register_model_provider`: Register a model provider
+- `load_chat_model`: Load a chat model
+
+#### `register_model_provider` Parameter Description
+
+- `provider_name`: Provider name, requires a custom name
+- `chat_model`: ChatModel class or string. If it's a string, it must be a provider supported by the official `init_chat_model` (e.g., `openai`, `anthropic`). In this case, the `init_chat_model` function will be called
+- `base_url`: Optional base URL. Recommended when `chat_model` is a string
+
+#### Usage Example
+
+```python
+from langchain_dev_utils.chat_model import register_model_provider, load_chat_model
+from langchain_qwq import ChatQwen
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Register custom model providers
+register_model_provider("dashscope", ChatQwen)
+register_model_provider("openrouter", "openai", base_url="https://openrouter.ai/api/v1")
+
+# Load models
+model = load_chat_model(model="dashscope:qwen-flash")
+print(model.invoke("Hello!"))
+
+model = load_chat_model(model="openrouter:moonshotai/kimi-k2-0905")
+print(model.invoke("Hello!"))
+```
+
+**Note**: Since the underlying implementation of the function is a global dictionary, **all model providers must be registered at application startup**. Modifications should not be made at runtime, otherwise multi-threading concurrency synchronization issues may occur.
+
+### 2. Reasoning Content Processing Functionality
+
+Provides utility functions for processing model reasoning content, supporting both synchronous and asynchronous operations.
+
+#### Core Functions
+
+- `convert_reasoning_content_for_ai_message`: Convert reasoning content for a single AI message
+- `convert_reasoning_content_for_chunk_iterator`: Convert reasoning content for streaming response message chunk iterator
+- `aconvert_reasoning_content_for_ai_message`: Asynchronously convert reasoning content for a single AI message
+- `aconvert_reasoning_content_for_chunk_iterator`: Asynchronously convert reasoning content for streaming response message chunk iterator
+
+#### Usage Example
+
+```python
+# Synchronously process reasoning content
+from langchain_dev_utils.content import convert_reasoning_content_for_ai_message
+
+response = model.invoke("Please solve this math problem")
+converted_response = convert_reasoning_content_for_ai_message(response, think_tag=("", ""))
+
+# Stream processing reasoning content
+from langchain_dev_utils.content import convert_reasoning_content_for_chunk_iterator
+
+for chunk in convert_reasoning_content_for_chunk_iterator(model.stream("Please solve this math problem"), think_tag=("", "")):
+    print(chunk.content, end="", flush=True)
+```
+
+### 3. Embeddings Model Loading Functionality
+
+Provides extended embeddings model loading functionality, similar to the model loading functionality.
+
+#### Core Functions
+
+- `register_embeddings_provider`: Register an embeddings model provider
+- `load_embeddings`: Load an embeddings model
+
+#### Usage Example
+
+```python
+from langchain_dev_utils.embbedings import register_embeddings_provider, load_embeddings
+
+# Register embeddings model provider
+register_embeddings_provider("openai", "openai", base_url="https://api.openai.com/v1")
+
+# Load embeddings model
+embeddings = load_embeddings("openai:text-embedding-ada-002")
+```
+
+### 4. Tool Calling Detection Functionality
+
+Provides a simple function to detect whether a message contains tool calls.
+
+#### Core Functions
+
+- `has_tool_calling`: Detect whether a message contains tool calls
+
+#### Usage Example
+
+```python
+from langchain_dev_utils.has_tool_calling import has_tool_calling
+
+if has_tool_calling(message):
+    # Handle tool calling logic
+    pass
+```
+
+## Test
+
+All the current tool functions in this project have been tested, and you can also clone this project for testing.
+
+```bash
+git clone https://github.com/TBice123123/langchain-dev-utils.git
+```
+
+```bash
+cd langchain-dev-utils
+```
+
+```bash
+uv sync --group test
+```
+
+```bash
+uv run pytest .
+```

langchain_dev_utils-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+langchain_dev_utils/__init__.py,sha256=v9MXwLR7iSJcZNV9rl7HfbqkMztYBfCoabT-hNiGdAE,779
+langchain_dev_utils/chat_model.py,sha256=HeihWUOJS1iRcjMTshbVVWeUcdjuHmfjG5aqL85SWh4,4402
+langchain_dev_utils/content.py,sha256=2FdyiFiqtEmCmIJ5n9EtxF-Z9cTj5cT7DPPxkU1CPiQ,4274
+langchain_dev_utils/embbedings.py,sha256=frq6WxYcPRRVTvfTHBqqu6xLmM2_03emmyDrkZxoDkE,4138
+langchain_dev_utils/has_tool_calling.py,sha256=w3JP7uc5khmAjBTH63rGXUWh6jrMX1ikg9FmEt8wdOc,524
+langchain_dev_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_dev_utils-0.1.0.dist-info/METADATA,sha256=yy1zkuW2SEI2cpfCuXEyNsIYA4m1oxyMc3dGZEQmf9w,5225
+langchain_dev_utils-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_dev_utils-0.1.0.dist-info/RECORD,,

langchain_dev_utils-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any