langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/memory/entity.py

@@ -4,13 +4,14 @@ import logging
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
 from itertools import islice
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.messages import BaseMessage, get_buffer_string
 from langchain_core.prompts import BasePromptTemplate
 from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.llm import LLMChain
 from langchain.memory.chat_memory import BaseChatMemory
@@ -20,6 +21,9 @@ from langchain.memory.prompt import (
 )
 from langchain.memory.utils import get_prompt_input_key
 
+if TYPE_CHECKING:
+    import sqlite3
+
 logger = logging.getLogger(__name__)
 
 
@@ -37,27 +41,22 @@ class BaseEntityStore(BaseModel, ABC):
     @abstractmethod
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         """Get entity value from store."""
-        pass
 
     @abstractmethod
     def set(self, key: str, value: Optional[str]) -> None:
         """Set entity value in store."""
-        pass
 
     @abstractmethod
     def delete(self, key: str) -> None:
         """Delete entity value from store."""
-        pass
 
     @abstractmethod
     def exists(self, key: str) -> bool:
         """Check if entity exists in store."""
-        pass
 
     @abstractmethod
     def clear(self) -> None:
         """Delete all entities from store."""
-        pass
 
 
 @deprecated(
@@ -73,18 +72,23 @@ class InMemoryEntityStore(BaseEntityStore):
 
     store: dict[str, Optional[str]] = {}
 
+    @override
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         return self.store.get(key, default)
 
+    @override
     def set(self, key: str, value: Optional[str]) -> None:
         self.store[key] = value
 
+    @override
     def delete(self, key: str) -> None:
         del self.store[key]
 
+    @override
     def exists(self, key: str) -> bool:
         return key in self.store
 
+    @override
     def clear(self) -> None:
         return self.store.clear()
 
@@ -115,20 +119,33 @@ class UpstashRedisEntityStore(BaseEntityStore):
         *args: Any,
         **kwargs: Any,
     ):
+        """Initializes the RedisEntityStore.
+
+        Args:
+            session_id: Unique identifier for the session.
+            url: URL of the Redis server.
+            token: Authentication token for the Redis server.
+            key_prefix: Prefix for keys in the Redis store.
+            ttl: Time-to-live for keys in seconds (default 1 day).
+            recall_ttl: Time-to-live extension for keys when recalled (default 3 days).
+        """
         try:
             from upstash_redis import Redis
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "Could not import upstash_redis python package. "
                 "Please install it with `pip install upstash_redis`."
             )
+            raise ImportError(msg) from e
 
         super().__init__(*args, **kwargs)
 
         try:
             self.redis_client = Redis(url=url, token=token)
-        except Exception:
-            logger.error("Upstash Redis instance could not be initiated.")
+        except Exception as exc:
+            error_msg = "Upstash Redis instance could not be initiated"
+            logger.exception(error_msg)
+            raise RuntimeError(error_msg) from exc
 
         self.session_id = session_id
         self.key_prefix = key_prefix
@@ -137,35 +154,49 @@ class UpstashRedisEntityStore(BaseEntityStore):
 
     @property
     def full_key_prefix(self) -> str:
+        """Returns the full key prefix with session ID."""
         return f"{self.key_prefix}:{self.session_id}"
 
+    @override
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         res = (
             self.redis_client.getex(f"{self.full_key_prefix}:{key}", ex=self.recall_ttl)
             or default
             or ""
         )
-        logger.debug(f"Upstash Redis MEM get '{self.full_key_prefix}:{key}': '{res}'")
+        logger.debug(
+            "Upstash Redis MEM get '%s:%s': '%s'", self.full_key_prefix, key, res
+        )
         return res
 
+    @override
     def set(self, key: str, value: Optional[str]) -> None:
         if not value:
             return self.delete(key)
         self.redis_client.set(f"{self.full_key_prefix}:{key}", value, ex=self.ttl)
         logger.debug(
-            f"Redis MEM set '{self.full_key_prefix}:{key}': '{value}' EX {self.ttl}"
+            "Redis MEM set '%s:%s': '%s' EX %s",
+            self.full_key_prefix,
+            key,
+            value,
+            self.ttl,
         )
+        return None
 
+    @override
     def delete(self, key: str) -> None:
         self.redis_client.delete(f"{self.full_key_prefix}:{key}")
 
+    @override
     def exists(self, key: str) -> bool:
         return self.redis_client.exists(f"{self.full_key_prefix}:{key}") == 1
 
+    @override
     def clear(self) -> None:
         def scan_and_delete(cursor: int) -> int:
             cursor, keys_to_delete = self.redis_client.scan(
-                cursor, f"{self.full_key_prefix}:*"
+                cursor,
+                f"{self.full_key_prefix}:*",
             )
             self.redis_client.delete(*keys_to_delete)
             return cursor
@@ -206,28 +237,40 @@ class RedisEntityStore(BaseEntityStore):
         *args: Any,
         **kwargs: Any,
     ):
+        """Initializes the RedisEntityStore.
+
+        Args:
+            session_id: Unique identifier for the session.
+            url: URL of the Redis server.
+            key_prefix: Prefix for keys in the Redis store.
+            ttl: Time-to-live for keys in seconds (default 1 day).
+            recall_ttl: Time-to-live extension for keys when recalled (default 3 days).
+        """
+
         try:
             import redis
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "Could not import redis python package. "
                 "Please install it with `pip install redis`."
             )
+            raise ImportError(msg) from e
 
         super().__init__(*args, **kwargs)
 
         try:
             from langchain_community.utilities.redis import get_client
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "Could not import langchain_community.utilities.redis.get_client. "
                 "Please install it with `pip install langchain-community`."
             )
+            raise ImportError(msg) from e
 
         try:
             self.redis_client = get_client(redis_url=url, decode_responses=True)
-        except redis.exceptions.ConnectionError as error:
-            logger.error(error)
+        except redis.exceptions.ConnectionError:
+            logger.exception("Redis client could not connect")
 
         self.session_id = session_id
         self.key_prefix = key_prefix
@@ -236,31 +279,42 @@ class RedisEntityStore(BaseEntityStore):
 
     @property
     def full_key_prefix(self) -> str:
+        """Returns the full key prefix with session ID."""
         return f"{self.key_prefix}:{self.session_id}"
 
+    @override
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         res = (
             self.redis_client.getex(f"{self.full_key_prefix}:{key}", ex=self.recall_ttl)
             or default
             or ""
         )
-        logger.debug(f"REDIS MEM get '{self.full_key_prefix}:{key}': '{res}'")
+        logger.debug("REDIS MEM get '%s:%s': '%s'", self.full_key_prefix, key, res)
         return res
 
+    @override
     def set(self, key: str, value: Optional[str]) -> None:
         if not value:
             return self.delete(key)
         self.redis_client.set(f"{self.full_key_prefix}:{key}", value, ex=self.ttl)
         logger.debug(
-            f"REDIS MEM set '{self.full_key_prefix}:{key}': '{value}' EX {self.ttl}"
+            "REDIS MEM set '%s:%s': '%s' EX %s",
+            self.full_key_prefix,
+            key,
+            value,
+            self.ttl,
         )
+        return None
 
+    @override
     def delete(self, key: str) -> None:
         self.redis_client.delete(f"{self.full_key_prefix}:{key}")
 
+    @override
     def exists(self, key: str) -> bool:
         return self.redis_client.exists(f"{self.full_key_prefix}:{key}") == 1
 
+    @override
     def clear(self) -> None:
         # iterate a list in batches of size batch_size
         def batched(iterable: Iterable[Any], batch_size: int) -> Iterable[Any]:
@@ -269,7 +323,8 @@ class RedisEntityStore(BaseEntityStore):
                 yield batch
 
         for keybatch in batched(
-            self.redis_client.scan_iter(f"{self.full_key_prefix}:*"), 500
+            self.redis_client.scan_iter(f"{self.full_key_prefix}:*"),
+            500,
         ):
             self.redis_client.delete(*keybatch)
 
@@ -283,7 +338,7 @@ class RedisEntityStore(BaseEntityStore):
     ),
 )
 class SQLiteEntityStore(BaseEntityStore):
-    """SQLite-backed Entity store"""
+    """SQLite-backed Entity store with safe query construction."""
 
     session_id: str = "default"
     table_name: str = "memory_store"
@@ -301,14 +356,28 @@ class SQLiteEntityStore(BaseEntityStore):
         *args: Any,
         **kwargs: Any,
     ):
+        """Initializes the SQLiteEntityStore.
+
+        Args:
+            session_id: Unique identifier for the session.
+            db_file: Path to the SQLite database file.
+            table_name: Name of the table to store entities.
+        """
+        super().__init__(*args, **kwargs)
         try:
             import sqlite3
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "Could not import sqlite3 python package. "
                 "Please install it with `pip install sqlite3`."
             )
-        super().__init__(*args, **kwargs)
+            raise ImportError(msg) from e
+
+        # Basic validation to prevent obviously malicious table/session names
+        if not table_name.isidentifier() or not session_id.isidentifier():
+            # Since we validate here, we can safely suppress the S608 bandit warning
+            msg = "Table name and session ID must be valid Python identifiers."
+            raise ValueError(msg)
 
         self.conn = sqlite3.connect(db_file)
         self.session_id = session_id
@@ -317,64 +386,65 @@ class SQLiteEntityStore(BaseEntityStore):
 
     @property
     def full_table_name(self) -> str:
+        """Returns the full table name with session ID."""
         return f"{self.table_name}_{self.session_id}"
 
+    def _execute_query(self, query: str, params: tuple = ()) -> "sqlite3.Cursor":
+        """Executes a query with proper connection handling."""
+        with self.conn:
+            return self.conn.execute(query, params)
+
     def _create_table_if_not_exists(self) -> None:
+        """Creates the entity table if it doesn't exist, using safe quoting."""
+        # Use standard SQL double quotes for the table name identifier
         create_table_query = f"""
-            CREATE TABLE IF NOT EXISTS {self.full_table_name} (
+            CREATE TABLE IF NOT EXISTS "{self.full_table_name}" (
                 key TEXT PRIMARY KEY,
                 value TEXT
             )
         """
-        with self.conn:
-            self.conn.execute(create_table_query)
+        self._execute_query(create_table_query)
 
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        query = f"""
-            SELECT value
-            FROM {self.full_table_name}
-            WHERE key = ?
-        """
-        cursor = self.conn.execute(query, (key,))
+        """Retrieves a value, safely quoting the table name."""
+        # `?` placeholder is used for the value to prevent SQL injection
+        # Ignore S608 since we validate for malicious table/session names in `__init__`
+        query = f'SELECT value FROM "{self.full_table_name}" WHERE key = ?'  # noqa: S608
+        cursor = self._execute_query(query, (key,))
         result = cursor.fetchone()
-        if result is not None:
-            value = result[0]
-            return value
-        return default
+        return result[0] if result is not None else default
 
     def set(self, key: str, value: Optional[str]) -> None:
+        """Inserts or replaces a value, safely quoting the table name."""
         if not value:
             return self.delete(key)
-        query = f"""
-            INSERT OR REPLACE INTO {self.full_table_name} (key, value)
-            VALUES (?, ?)
-        """
-        with self.conn:
-            self.conn.execute(query, (key, value))
+        # Ignore S608 since we validate for malicious table/session names in `__init__`
+        query = (
+            "INSERT OR REPLACE INTO "  # noqa: S608
+            f'"{self.full_table_name}" (key, value) VALUES (?, ?)'
+        )
+        self._execute_query(query, (key, value))
+        return None
 
     def delete(self, key: str) -> None:
-        query = f"""
-            DELETE FROM {self.full_table_name}
-            WHERE key = ?
-        """
-        with self.conn:
-            self.conn.execute(query, (key,))
+        """Deletes a key-value pair, safely quoting the table name."""
+        # Ignore S608 since we validate for malicious table/session names in `__init__`
+        query = f'DELETE FROM "{self.full_table_name}" WHERE key = ?'  # noqa: S608
+        self._execute_query(query, (key,))
 
     def exists(self, key: str) -> bool:
-        query = f"""
-            SELECT 1
-            FROM {self.full_table_name}
-            WHERE key = ?
-            LIMIT 1
-        """
-        cursor = self.conn.execute(query, (key,))
-        result = cursor.fetchone()
-        return result is not None
+        """Checks for the existence of a key, safely quoting the table name."""
+        # Ignore S608 since we validate for malicious table/session names in `__init__`
+        query = f'SELECT 1 FROM "{self.full_table_name}" WHERE key = ? LIMIT 1'  # noqa: S608
+        cursor = self._execute_query(query, (key,))
+        return cursor.fetchone() is not None
 
+    @override
     def clear(self) -> None:
+        # Ignore S608 since we validate for malicious table/session names in `__init__`
         query = f"""
             DELETE FROM {self.full_table_name}
-        """
+        """  # noqa: S608
         with self.conn:
             self.conn.execute(query)
 

langchain/memory/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 _DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE = """You are an assistant to a human, powered by a large language model trained by OpenAI.
@@ -16,7 +15,7 @@ Current conversation:
 {history}
 Last line:
 Human: {input}
-You:"""
+You:"""  # noqa: E501
 
 ENTITY_MEMORY_CONVERSATION_TEMPLATE = PromptTemplate(
     input_variables=["entities", "history", "input"],
@@ -43,7 +42,7 @@ Current summary:
 New lines of conversation:
 {new_lines}
 
-New summary:"""
+New summary:"""  # noqa: E501
 SUMMARY_PROMPT = PromptTemplate(
     input_variables=["summary", "new_lines"], template=_DEFAULT_SUMMARIZER_TEMPLATE
 )
@@ -81,7 +80,7 @@ Conversation history (for reference only):
 Last line of conversation (for extraction):
 Human: {input}
 
-Output:"""
+Output:"""  # noqa: E501
 ENTITY_EXTRACTION_PROMPT = PromptTemplate(
     input_variables=["history", "input"], template=_DEFAULT_ENTITY_EXTRACTION_TEMPLATE
 )
@@ -102,7 +101,7 @@ Existing summary of {entity}:
 
 Last line of conversation:
 Human: {input}
-Updated summary:"""
+Updated summary:"""  # noqa: E501
 
 ENTITY_SUMMARIZATION_PROMPT = PromptTemplate(
     input_variables=["entity", "summary", "history", "input"],
@@ -128,7 +127,7 @@ _DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE = (
     "Person #1: It's a secret military base in Nevada.\n"
     "AI: What do you know about Nevada?\n"
     "Last line of conversation:\n"
-    "Person #1: It's a state in the US. It's also the number 1 producer of gold in the US.\n\n"
+    "Person #1: It's a state in the US. It's also the number 1 producer of gold in the US.\n\n"  # noqa: E501
     f"Output: (Nevada, is a, state){KG_TRIPLE_DELIMITER}(Nevada, is in, US)"
     f"{KG_TRIPLE_DELIMITER}(Nevada, is the number 1 producer of, gold)\n"
     "END OF EXAMPLE\n\n"
@@ -145,12 +144,12 @@ _DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE = (
     "EXAMPLE\n"
     "Conversation history:\n"
     "Person #1: What do you know about Descartes?\n"
-    "AI: Descartes was a French philosopher, mathematician, and scientist who lived in the 17th century.\n"
-    "Person #1: The Descartes I'm referring to is a standup comedian and interior designer from Montreal.\n"
-    "AI: Oh yes, He is a comedian and an interior designer. He has been in the industry for 30 years. His favorite food is baked bean pie.\n"
+    "AI: Descartes was a French philosopher, mathematician, and scientist who lived in the 17th century.\n"  # noqa: E501
+    "Person #1: The Descartes I'm referring to is a standup comedian and interior designer from Montreal.\n"  # noqa: E501
+    "AI: Oh yes, He is a comedian and an interior designer. He has been in the industry for 30 years. His favorite food is baked bean pie.\n"  # noqa: E501
     "Last line of conversation:\n"
-    "Person #1: Oh huh. I know Descartes likes to drive antique scooters and play the mandolin.\n"
-    f"Output: (Descartes, likes to drive, antique scooters){KG_TRIPLE_DELIMITER}(Descartes, plays, mandolin)\n"
+    "Person #1: Oh huh. I know Descartes likes to drive antique scooters and play the mandolin.\n"  # noqa: E501
+    f"Output: (Descartes, likes to drive, antique scooters){KG_TRIPLE_DELIMITER}(Descartes, plays, mandolin)\n"  # noqa: E501
     "END OF EXAMPLE\n\n"
     "Conversation history (for reference only):\n"
     "{history}"

langchain/memory/readonly.py

@@ -19,8 +19,6 @@ class ReadOnlySharedMemory(BaseMemory):
 
     def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
         """Nothing should be saved or changed"""
-        pass
 
     def clear(self) -> None:
         """Nothing to clear, got a memory like a vault."""
-        pass

langchain/memory/simple.py

@@ -1,6 +1,7 @@
 from typing import Any
 
 from langchain_core.memory import BaseMemory
+from typing_extensions import override
 
 
 class SimpleMemory(BaseMemory):
@@ -8,19 +9,19 @@ class SimpleMemory(BaseMemory):
     ever change between prompts.
     """
 
-    memories: dict[str, Any] = dict()
+    memories: dict[str, Any] = {}
 
     @property
+    @override
     def memory_variables(self) -> list[str]:
         return list(self.memories.keys())
 
+    @override
     def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, str]:
         return self.memories
 
     def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
         """Nothing should be saved or changed, my memory is set in stone."""
-        pass
 
     def clear(self) -> None:
         """Nothing to clear, got a memory like a vault."""
-        pass

langchain/memory/summary.py

@@ -3,14 +3,13 @@ from __future__ import annotations
 from typing import Any
 
 from langchain_core._api import deprecated
-from langchain_core.caches import BaseCache as BaseCache  # For model_rebuild
-from langchain_core.callbacks import Callbacks as Callbacks  # For model_rebuild
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.messages import BaseMessage, SystemMessage, get_buffer_string
 from langchain_core.prompts import BasePromptTemplate
 from langchain_core.utils import pre_init
 from pydantic import BaseModel
+from typing_extensions import override
 
 from langchain.chains.llm import LLMChain
 from langchain.memory.chat_memory import BaseChatMemory
@@ -22,7 +21,7 @@ from langchain.memory.prompt import SUMMARY_PROMPT
     removal="1.0",
     message=(
         "Refer here for how to incorporate summaries of conversation history: "
-        "https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/"  # noqa: E501
+        "https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/"
     ),
 )
 class SummarizerMixin(BaseModel):
@@ -35,8 +34,19 @@ class SummarizerMixin(BaseModel):
     summary_message_cls: type[BaseMessage] = SystemMessage
 
     def predict_new_summary(
-        self, messages: list[BaseMessage], existing_summary: str
+        self,
+        messages: list[BaseMessage],
+        existing_summary: str,
     ) -> str:
+        """Predict a new summary based on the messages and existing summary.
+
+        Args:
+            messages: List of messages to summarize.
+            existing_summary: Existing summary to build upon.
+
+        Returns:
+            A new summary string.
+        """
         new_lines = get_buffer_string(
             messages,
             human_prefix=self.human_prefix,
@@ -47,8 +57,19 @@ class SummarizerMixin(BaseModel):
         return chain.predict(summary=existing_summary, new_lines=new_lines)
 
     async def apredict_new_summary(
-        self, messages: list[BaseMessage], existing_summary: str
+        self,
+        messages: list[BaseMessage],
+        existing_summary: str,
     ) -> str:
+        """Predict a new summary based on the messages and existing summary.
+
+        Args:
+            messages: List of messages to summarize.
+            existing_summary: Existing summary to build upon.
+
+        Returns:
+            A new summary string.
+        """
         new_lines = get_buffer_string(
             messages,
             human_prefix=self.human_prefix,
@@ -87,10 +108,21 @@ class ConversationSummaryMemory(BaseChatMemory, SummarizerMixin):
         summarize_step: int = 2,
         **kwargs: Any,
     ) -> ConversationSummaryMemory:
+        """Create a ConversationSummaryMemory from a list of messages.
+
+        Args:
+            llm: The language model to use for summarization.
+            chat_memory: The chat history to summarize.
+            summarize_step: Number of messages to summarize at a time.
+            **kwargs: Additional keyword arguments to pass to the class.
+        Returns:
+            An instance of ConversationSummaryMemory with the summarized history.
+        """
         obj = cls(llm=llm, chat_memory=chat_memory, **kwargs)
         for i in range(0, len(obj.chat_memory.messages), summarize_step):
             obj.buffer = obj.predict_new_summary(
-                obj.chat_memory.messages[i : i + summarize_step], obj.buffer
+                obj.chat_memory.messages[i : i + summarize_step],
+                obj.buffer,
             )
         return obj
 
@@ -102,6 +134,7 @@ class ConversationSummaryMemory(BaseChatMemory, SummarizerMixin):
         """
         return [self.memory_key]
 
+    @override
     def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Return history buffer."""
         if self.return_messages:
@@ -116,23 +149,22 @@ class ConversationSummaryMemory(BaseChatMemory, SummarizerMixin):
         prompt_variables = values["prompt"].input_variables
         expected_keys = {"summary", "new_lines"}
         if expected_keys != set(prompt_variables):
-            raise ValueError(
+            msg = (
                 "Got unexpected prompt input variables. The prompt expects "
                 f"{prompt_variables}, but it should have {expected_keys}."
             )
+            raise ValueError(msg)
         return values
 
     def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
         """Save context from this conversation to buffer."""
         super().save_context(inputs, outputs)
         self.buffer = self.predict_new_summary(
-            self.chat_memory.messages[-2:], self.buffer
+            self.chat_memory.messages[-2:],
+            self.buffer,
         )
 
     def clear(self) -> None:
         """Clear memory contents."""
         super().clear()
         self.buffer = ""
-
-
-ConversationSummaryMemory.model_rebuild()