langchain-deepseek 0.0.1__tar.gz

langchain_deepseek-0.0.1/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: langchain-deepseek
+Version: 0.0.1
+Summary: 
+Author: SyJarvis
+Author-email: 1755115828@qq.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: langchain (>=0.2.6)
+Description-Content-Type: text/markdown
+
+<center><h2>🚀 Langchain-Deepseek: Using the deepseek model in langchain</h2></center>
+## Install
+
+* Install from source (Recommend)
+
+```bash
+cd langchain-deepseek
+pip install -e .
+```
+* Install from PyPI
+```bash
+pip install langchain-deepseek
+```
+
+## Quick Start
+* All the code can be found in the `examples`
+* Set DeepSeek API key in environment if using DeepSeek models: `export DEEPSEEK_API_KEY="sk-...".`
+*  Maybe you can try loading environment variables like this. Create a new `.env` file
+```
+DEEPSEEK_API_KEY="sk-..."
+```
+```python
+from dotenv import load_dotenv, find_dotenv
+load_dotenv(find_dotenv(), override=True)
+```
+##### It works with the Langchain library
+
+```python
+from langchain_deepseek import ChatDeepSeekAI
+from langchain_core.output_parsers import StrOutputParser
+
+llm = ChatDeepSeekAI(
+    model="deepseek-chat",
+    api_key="sk-...",
+)
+
+output_parser = StrOutputParser()
+chain = llm | output_parser
+response = chain.invoke("太阳系有几大行星？")
+print(response)
+```
+
+
+
+## 🌟Citation
+
+```python
+@article{guo2025langchain-deepseek,
+title={langchain-deepseek: Using the deepseek model in langchain},
+author={Runke Zhong},
+year={2025}
+}
+```
+**保持热爱，奔赴星海！**
+
+*这个世界上唯有两样东西能让我们的心灵感到深深的震撼：一是我们头上灿烂的星空，一是我们内心崇高的道德法则*
+

langchain_deepseek-0.0.1/README.md

@@ -0,0 +1,56 @@
+<center><h2>🚀 Langchain-Deepseek: Using the deepseek model in langchain</h2></center>
+## Install
+
+* Install from source (Recommend)
+
+```bash
+cd langchain-deepseek
+pip install -e .
+```
+* Install from PyPI
+```bash
+pip install langchain-deepseek
+```
+
+## Quick Start
+* All the code can be found in the `examples`
+* Set DeepSeek API key in environment if using DeepSeek models: `export DEEPSEEK_API_KEY="sk-...".`
+*  Maybe you can try loading environment variables like this. Create a new `.env` file
+```
+DEEPSEEK_API_KEY="sk-..."
+```
+```python
+from dotenv import load_dotenv, find_dotenv
+load_dotenv(find_dotenv(), override=True)
+```
+##### It works with the Langchain library
+
+```python
+from langchain_deepseek import ChatDeepSeekAI
+from langchain_core.output_parsers import StrOutputParser
+
+llm = ChatDeepSeekAI(
+    model="deepseek-chat",
+    api_key="sk-...",
+)
+
+output_parser = StrOutputParser()
+chain = llm | output_parser
+response = chain.invoke("太阳系有几大行星？")
+print(response)
+```
+
+
+
+## 🌟Citation
+
+```python
+@article{guo2025langchain-deepseek,
+title={langchain-deepseek: Using the deepseek model in langchain},
+author={Runke Zhong},
+year={2025}
+}
+```
+**保持热爱，奔赴星海！**
+
+*这个世界上唯有两样东西能让我们的心灵感到深深的震撼：一是我们头上灿烂的星空，一是我们内心崇高的道德法则*

langchain_deepseek-0.0.1/langchain_deepseek/__init__.py

@@ -0,0 +1,6 @@
+
+from .base import ChatDeepSeekAI
+
+__version__ = "0.0.1"
+__author__ = "Runke Zhong"
+__url__ = "https://github.com/SyJarvis/langchain-deepseek"

langchain_deepseek-0.0.1/langchain_deepseek/api.py

@@ -0,0 +1,77 @@
+from pydantic import BaseModel, Field
+import os
+import requests
+import json
+from .const import DEFAULT_BASE_URL
+from .exceptions import AuthenticationError, BadRequestError, APITimeoutError
+
+
+class RestAPI:
+    """
+    访问大模型的REST API
+    """
+    def __init__(
+        self,
+        base_url: str = None,
+        api_key: str = None
+    ):
+        env_base_url = os.getenv("DEEPSEEK_BASE_URL")
+        env_api_key = os.getenv("DEEPSEEK_API_KEY")
+        if base_url is None:
+            base_url = env_base_url if env_base_url else DEFAULT_BASE_URL
+        if api_key is None:
+            if env_api_key is None:
+                raise ValueError("`DEEPSEEK_API_KEY` is required")
+            else:
+                api_key = env_api_key
+        self.base_url = base_url
+        self.api_key = api_key
+        self.session = requests.Session()
+
+    def action_post(self, request_path: str, datas: str=None, **kwargs):
+        """POST"""
+        url = self.base_url + "/" + request_path
+        headers = self._generate_headers()
+        payload = datas if datas else json.dumps(kwargs)
+        for _ in range(3):
+            try:
+                response = self.session.post(url, headers=headers, data=payload)
+            except Exception as e:
+                print("Retry for HTTP Error ...")
+                continue
+            else:
+                if response.status_code == 401:
+                    raise AuthenticationError(
+                        "认证失败：无效的API密钥或未授权访问",
+                        response=response,
+                        body=response.text
+                    )
+                elif response.status_code == 400:
+                    raise BadRequestError(
+                        "请求参数错误",
+                        response=response,
+                        body=response.text
+                    )
+                elif response.status_code == 200:
+                    break
+        else:
+            raise APITimeoutError("连接超时")
+        
+        if response.text:
+            resp = response.json()
+            return resp
+        else:
+            return {}
+        
+    def close(self):
+        """关闭会话"""
+        self.session.close()
+
+    def _generate_headers(self, token=None) -> dict:
+        if token is None:
+            token = self.api_key
+        return {
+            "Content-Type": 'application/json',
+            'Accept': 'application/json',
+            'Authorization': f'Bearer {token}'
+        }

langchain_deepseek-0.0.1/langchain_deepseek/base.py

@@ -0,0 +1,199 @@
+import inspect
+from typing import (
+    Dict,
+    List,
+    Any,
+    Optional,
+    Mapping,
+    Tuple
+)
+
+from langchain_core.language_models.chat_models import (
+    BaseChatModel,
+    generate_from_stream
+)
+
+from langchain_core.messages import (
+    BaseMessage
+)
+
+from langchain_core.outputs import (
+    ChatResult,
+    ChatGeneration
+)
+
+from langchain_core.callbacks import (
+    CallbackManagerForLLMRun
+)
+
+from langchain_community.adapters.openai import (
+    convert_message_to_dict,
+    convert_dict_to_message
+)
+
+from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
+
+from .api import RestAPI
+
+
+class ChatDeepSeekAI(BaseChatModel):
+    """`DeepSeek` Chat large language models API.
+    
+    """
+
+    @property
+    def lc_secrets(self) -> Dict[str, str]:
+        return {"deepseek_api_key": "DEEPSEEK_API_KEY"}
+
+    @classmethod
+    def get_lc_namespace(cls) -> List[str]:
+        """Return"""
+        return ["langchain", "chat_models", "DeepSeek"]
+
+    @property
+    def lc_attributes(self) -> Dict[str, Any]:
+        attributes: Dict[str, Any] = {}
+        return attributes
+
+    @property
+    def _llm_type(self) -> str:
+        """Return the type of chat model."""
+        return "DeepSeekAI"
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        return {**{"model_name": self.model}, **self._default_params}
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        params = {
+            "model": self.model,
+            "stream": self.streaming,
+            "n": self.n,
+            "temperature": self.temperature,
+            # **self.model_kwargs
+        }
+        if self.max_tokens is not None:
+            params["max_tokens"] = self.max_tokens
+        return params
+
+    """deepseek client"""
+    client: Any = Field(default=None, exclude=True)
+    """model name use"""
+    model: str = Field(default="deepseek-chat")
+    api_key: Optional[str] = Field(default=None, exclude=True)
+    base_url: Optional[str] = Field(default=None)
+    temperature: Optional[float] = Field(default=1)
+    top_p: Optional[float] = Field(default=1)
+    request_id: Optional[str] = Field(default=None)
+    max_tokens: Optional[int] = Field(default=2048)
+    streaming: Optional[bool] = Field(default=False)
+    n: Optional[int] = Field(default=1)
+    response_format: Dict[str, str] = Field(default={"type": "text"})
+    frequency_penalty: Optional[int] = Field(default=0)
+    presence_penalty: Optional[int] = Field(default=0)
+    tools: Any = Field(default=None)
+    tool_choice: Optional[str] = Field(default="none")
+    logprobs: Optional[bool] = Field(default=False)
+    top_logprobs: Optional[int] = Field(default=None)
+
+    @classmethod
+    def filter_model_kwargs(cls):
+        """
+        """
+        return [
+            "model",
+            "frequency_penalty",
+            "max_tokens",
+            "presence_penalty",
+            "response_format",
+            "stop",
+            "stream",
+            "temperature",
+            "top_p",
+            "tools",
+            "tool_choice",
+            "logprobs",
+            "top_logprobs",
+            "request_id"
+        ]
+
+    def _generate(
+            self,
+            messages: List[BaseMessage],
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            stream: Optional[bool] = None,
+            **kwargs: Any
+    ) -> ChatResult:
+        should_stream = stream if stream is not None else self.streaming
+        if should_stream:
+            stream_iter = self._stream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
+            )
+            return generate_from_stream(stream_iter)
+        message_dict, params = self._create_message_dicts(messages, stop)
+        response = self.completion_with_retry(
+            message_dict=message_dict,
+            run_manager=run_manager,
+            params=params
+        )
+        return self._create_chat_result(response)
+
+    def completion_with_retry(
+            self, message_dict=None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs
+    ):
+        params = kwargs["params"]
+        params.update({"messages": message_dict})
+        try:
+            self.client = RestAPI(base_url=self.base_url, api_key=self.api_key)
+            reply = self.client.action_post(request_path=f"chat/completions", **params)
+        except Exception as e:
+            raise e
+        return reply
+
+    def _create_chat_result(self, response):
+        generations = []
+        id = response.get("id")
+        if not isinstance(response, dict):
+            response = response.dict()
+        for res in response["choices"]:
+            message_dict = res["message"]
+            message = convert_dict_to_message(message_dict)
+            generation_info = dict(finish_reason=res.get("finish_reason"))
+            gen = ChatGeneration(
+                message=message,
+                generation_info=generation_info,
+            )
+            generations.append(gen)
+        token_usage = response.get("usage", {})
+        llm_output = {
+            "id": id,
+            "created": response.get("created"),
+            "token_usage": token_usage,
+            "model_name": self.model,
+        }
+        return ChatResult(generations=generations, llm_output=llm_output)
+
+    def _create_message_dicts(
+            self, messages: List[BaseMessage], stop: Optional[List[str]]
+    ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        params = self.get_model_kwargs()
+        params.update({"stream": False})
+        if stop is not None:
+            if "stop" in params:
+                raise ValueError("`stop` found in both the input and default params.")
+            params.update({"stop": stop})
+        message_dicts = [convert_message_to_dict(message) for message in messages]
+        # 传递prompt
+        params.update({"messages": message_dicts})
+        return message_dicts, params
+
+    def get_model_kwargs(self):
+        attrs = {}
+        for cls in inspect.getmro(self.__class__):
+            attrs.update(vars(cls))
+        attrs.update((vars(self)))
+        return {
+            attr: value for attr, value in attrs.items() if attr in self.__class__.filter_model_kwargs() and value is not None
+        }

langchain_deepseek-0.0.1/langchain_deepseek/const.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+DEFAULT_BASE_URL = "https://api.deepseek.com"
+ERROR_MESSAGE = "use llm model faild"

langchain_deepseek-0.0.1/langchain_deepseek/exceptions.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+import httpx
+import requests
+from typing import Any, Optional, Literal
+
+__all__ = [
+    "AuthenticationError",
+    "BadRequestError",
+]
+
+
+class DeepSeekError(Exception):
+    pass
+
+
+class APIError(DeepSeekError):
+    message: str = None
+    request: Optional[httpx.Request] = None
+    body: Any = None
+    code: Optional[str] = None
+    param: Optional[str] = None
+    type: Optional[str]
+
+    def __init__(self, message: str, request: httpx.Request, *, body: object | None) -> None:
+        self.message = message
+        self.request = request
+        self.body = body
+
+
+class APIStatusError(APIError):
+    """Raised when an API response has a status code of 4xx or 5xx."""
+
+    response: httpx.Response
+    status_code: int
+    request_id: str | None
+
+    def __init__(self, message: str, *, response: httpx.Response, body: object | None) -> None:
+        super().__init__(message, response.request, body=body)
+        self.response = response
+        self.status_code = response.status_code
+        self.request_id = response.headers.get("x-request-id")
+
+
+class APIConnectionError(APIError):
+    def __init__(self, *, message: str = "Connection error.", request: httpx.Request) -> None:
+        super().__init__(message, request, body=None)
+
+
+class APITimeoutError(APIConnectionError):
+    def __init__(self, request: httpx.Request) -> None:
+        super().__init__(message="Request timed out.", request=request)
+
+
+class AuthenticationError(APIStatusError):
+    status_code: Literal[401] = 401
+
+
+class BadRequestError(APIStatusError):
+    status_code: Literal[400] = 400

langchain_deepseek-0.0.1/langchain_deepseek/tools.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

langchain_deepseek-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "langchain-deepseek"
+version = "0.0.1"
+description = ""
+authors = [
+    {name = "SyJarvis",email = "1755115828@qq.com"}
+]
+readme = "README.md"
+requires-python = ">=3.9,<4.0"
+dependencies = [
+    "langchain (>=0.2.6)"
+]
+
+[[tool.poetry.source]]
+name = "aliyun"
+url = "https://mirrors.aliyun.com/pypi/simple/"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"