instruction stringclasses 100
values | code stringlengths 78 193k | response stringlengths 259 170k | file stringlengths 59 203 |
|---|---|---|---|
Help me write clear docstrings | import logging
import uuid
from typing import Dict, List, Mapping, Optional
from urllib.parse import urlparse
from pydantic import BaseModel
try:
import weaviate
except ImportError:
raise ImportError(
"The 'weaviate' library is required. Please install it using 'pip install weaviate-client weaviate'."
)
import weaviate.classes.config as wvcc
from weaviate.classes.init import AdditionalConfig, Auth, Timeout
from weaviate.classes.query import Filter, MetadataQuery
from weaviate.util import get_valid_uuid
from mem0.vector_stores.base import VectorStoreBase
logger = logging.getLogger(__name__)
class OutputData(BaseModel):
id: str
score: float
payload: Dict
class Weaviate(VectorStoreBase):
def __init__(
self,
collection_name: str,
embedding_model_dims: int,
cluster_url: str = None,
auth_client_secret: str = None,
additional_headers: dict = None,
):
if "localhost" in cluster_url:
self.client = weaviate.connect_to_local(headers=additional_headers)
elif auth_client_secret:
self.client = weaviate.connect_to_weaviate_cloud(
cluster_url=cluster_url,
auth_credentials=Auth.api_key(auth_client_secret),
headers=additional_headers,
)
else:
parsed = urlparse(cluster_url) # e.g., http://mem0_store:8080
http_host = parsed.hostname or "localhost"
http_port = parsed.port or (443 if parsed.scheme == "https" else 8080)
http_secure = parsed.scheme == "https"
# Weaviate gRPC defaults (inside Docker network)
grpc_host = http_host
grpc_port = 50051
grpc_secure = False
self.client = weaviate.connect_to_custom(
http_host,
http_port,
http_secure,
grpc_host,
grpc_port,
grpc_secure,
headers=additional_headers,
skip_init_checks=True,
additional_config=AdditionalConfig(timeout=Timeout(init=2.0)),
)
self.collection_name = collection_name
self.embedding_model_dims = embedding_model_dims
self.create_col(embedding_model_dims)
def _parse_output(self, data: Dict) -> List[OutputData]:
keys = ["ids", "distances", "metadatas"]
values = []
for key in keys:
value = data.get(key, [])
if isinstance(value, list) and value and isinstance(value[0], list):
value = value[0]
values.append(value)
ids, distances, metadatas = values
max_length = max(len(v) for v in values if isinstance(v, list) and v is not None)
result = []
for i in range(max_length):
entry = OutputData(
id=ids[i] if isinstance(ids, list) and ids and i < len(ids) else None,
score=(distances[i] if isinstance(distances, list) and distances and i < len(distances) else None),
payload=(metadatas[i] if isinstance(metadatas, list) and metadatas and i < len(metadatas) else None),
)
result.append(entry)
return result
def create_col(self, vector_size, distance="cosine"):
if self.client.collections.exists(self.collection_name):
logger.debug(f"Collection {self.collection_name} already exists. Skipping creation.")
return
properties = [
wvcc.Property(name="ids", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="hash", data_type=wvcc.DataType.TEXT),
wvcc.Property(
name="metadata",
data_type=wvcc.DataType.TEXT,
description="Additional metadata",
),
wvcc.Property(name="data", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="created_at", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="category", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="updated_at", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="user_id", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="agent_id", data_type=wvcc.DataType.TEXT),
wvcc.Property(name="run_id", data_type=wvcc.DataType.TEXT),
]
vectorizer_config = wvcc.Configure.Vectorizer.none()
vector_index_config = wvcc.Configure.VectorIndex.hnsw()
self.client.collections.create(
self.collection_name,
vectorizer_config=vectorizer_config,
vector_index_config=vector_index_config,
properties=properties,
)
def insert(self, vectors, payloads=None, ids=None):
logger.info(f"Inserting {len(vectors)} vectors into collection {self.collection_name}")
with self.client.batch.fixed_size(batch_size=100) as batch:
for idx, vector in enumerate(vectors):
object_id = ids[idx] if ids and idx < len(ids) else str(uuid.uuid4())
object_id = get_valid_uuid(object_id)
data_object = payloads[idx] if payloads and idx < len(payloads) else {}
# Ensure 'id' is not included in properties (it's used as the Weaviate object ID)
if "ids" in data_object:
del data_object["ids"]
batch.add_object(collection=self.collection_name, properties=data_object, uuid=object_id, vector=vector)
def search(
self, query: str, vectors: List[float], limit: int = 5, filters: Optional[Dict] = None
) -> List[OutputData]:
collection = self.client.collections.get(str(self.collection_name))
filter_conditions = []
if filters:
for key, value in filters.items():
if value and key in ["user_id", "agent_id", "run_id"]:
filter_conditions.append(Filter.by_property(key).equal(value))
combined_filter = Filter.all_of(filter_conditions) if filter_conditions else None
response = collection.query.hybrid(
query="",
vector=vectors,
limit=limit,
filters=combined_filter,
return_properties=["hash", "created_at", "updated_at", "user_id", "agent_id", "run_id", "data", "category"],
return_metadata=MetadataQuery(score=True),
)
results = []
for obj in response.objects:
payload = obj.properties.copy()
for id_field in ["run_id", "agent_id", "user_id"]:
if id_field in payload and payload[id_field] is None:
del payload[id_field]
payload["id"] = str(obj.uuid).split("'")[0] # Include the id in the payload
if obj.metadata.distance is not None:
score = 1 - obj.metadata.distance # Convert distance to similarity score
elif obj.metadata.score is not None:
score = obj.metadata.score
else:
score = 1.0 # Default score if none provided
results.append(
OutputData(
id=str(obj.uuid),
score=score,
payload=payload,
)
)
return results
def delete(self, vector_id):
collection = self.client.collections.get(str(self.collection_name))
collection.data.delete_by_id(vector_id)
def update(self, vector_id, vector=None, payload=None):
collection = self.client.collections.get(str(self.collection_name))
if payload:
collection.data.update(uuid=vector_id, properties=payload)
if vector:
existing_data = self.get(vector_id)
if existing_data:
existing_data = dict(existing_data)
if "id" in existing_data:
del existing_data["id"]
existing_payload: Mapping[str, str] = existing_data
collection.data.update(uuid=vector_id, properties=existing_payload, vector=vector)
def get(self, vector_id):
vector_id = get_valid_uuid(vector_id)
collection = self.client.collections.get(str(self.collection_name))
response = collection.query.fetch_object_by_id(
uuid=vector_id,
return_properties=["hash", "created_at", "updated_at", "user_id", "agent_id", "run_id", "data", "category"],
)
# results = {}
# print("reponse",response)
# for obj in response.objects:
payload = response.properties.copy()
payload["id"] = str(response.uuid).split("'")[0]
results = OutputData(
id=str(response.uuid).split("'")[0],
score=1.0,
payload=payload,
)
return results
def list_cols(self):
collections = self.client.collections.list_all()
logger.debug(f"collections: {collections}")
print(f"collections: {collections}")
return {"collections": [{"name": col.name} for col in collections]}
def delete_col(self):
self.client.collections.delete(self.collection_name)
def col_info(self):
schema = self.client.collections.get(self.collection_name)
if schema:
return schema
return None
def list(self, filters=None, limit=100) -> List[OutputData]:
collection = self.client.collections.get(self.collection_name)
filter_conditions = []
if filters:
for key, value in filters.items():
if value and key in ["user_id", "agent_id", "run_id"]:
filter_conditions.append(Filter.by_property(key).equal(value))
combined_filter = Filter.all_of(filter_conditions) if filter_conditions else None
response = collection.query.fetch_objects(
limit=limit,
filters=combined_filter,
return_properties=["hash", "created_at", "updated_at", "user_id", "agent_id", "run_id", "data", "category"],
)
results = []
for obj in response.objects:
payload = obj.properties.copy()
payload["id"] = str(obj.uuid).split("'")[0]
results.append(OutputData(id=str(obj.uuid).split("'")[0], score=1.0, payload=payload))
return [results]
def reset(self):
logger.warning(f"Resetting index {self.collection_name}...")
self.delete_col()
self.create_col() | --- +++ @@ -37,6 +37,17 @@ auth_client_secret: str = None,
additional_headers: dict = None,
):
+ """
+ Initialize the Weaviate vector store.
+
+ Args:
+ collection_name (str): Name of the collection/class in Weaviate.
+ embedding_model_dims (int): Dimensions of the embedding model.
+ client (WeaviateClient, optional): Existing Weaviate client instance. Defaults to None.
+ cluster_url (str, optional): URL for Weaviate server. Defaults to None.
+ auth_config (dict, optional): Authentication configuration for Weaviate. Defaults to None.
+ additional_headers (dict, optional): Additional headers for requests. Defaults to None.
+ """
if "localhost" in cluster_url:
self.client = weaviate.connect_to_local(headers=additional_headers)
elif auth_client_secret:
@@ -73,6 +84,15 @@ self.create_col(embedding_model_dims)
def _parse_output(self, data: Dict) -> List[OutputData]:
+ """
+ Parse the output data.
+
+ Args:
+ data (Dict): Output data.
+
+ Returns:
+ List[OutputData]: Parsed output data.
+ """
keys = ["ids", "distances", "metadatas"]
values = []
@@ -97,6 +117,13 @@ return result
def create_col(self, vector_size, distance="cosine"):
+ """
+ Create a new collection with the specified schema.
+
+ Args:
+ vector_size (int): Size of the vectors to be stored.
+ distance (str, optional): Distance metric for vector similarity. Defaults to "cosine".
+ """
if self.client.collections.exists(self.collection_name):
logger.debug(f"Collection {self.collection_name} already exists. Skipping creation.")
return
@@ -129,6 +156,14 @@ )
def insert(self, vectors, payloads=None, ids=None):
+ """
+ Insert vectors into a collection.
+
+ Args:
+ vectors (list): List of vectors to insert.
+ payloads (list, optional): List of payloads corresponding to vectors. Defaults to None.
+ ids (list, optional): List of IDs corresponding to vectors. Defaults to None.
+ """
logger.info(f"Inserting {len(vectors)} vectors into collection {self.collection_name}")
with self.client.batch.fixed_size(batch_size=100) as batch:
for idx, vector in enumerate(vectors):
@@ -146,6 +181,9 @@ def search(
self, query: str, vectors: List[float], limit: int = 5, filters: Optional[Dict] = None
) -> List[OutputData]:
+ """
+ Search for similar vectors.
+ """
collection = self.client.collections.get(str(self.collection_name))
filter_conditions = []
if filters:
@@ -186,10 +224,24 @@ return results
def delete(self, vector_id):
+ """
+ Delete a vector by ID.
+
+ Args:
+ vector_id: ID of the vector to delete.
+ """
collection = self.client.collections.get(str(self.collection_name))
collection.data.delete_by_id(vector_id)
def update(self, vector_id, vector=None, payload=None):
+ """
+ Update a vector and its payload.
+
+ Args:
+ vector_id: ID of the vector to update.
+ vector (list, optional): Updated vector. Defaults to None.
+ payload (dict, optional): Updated payload. Defaults to None.
+ """
collection = self.client.collections.get(str(self.collection_name))
if payload:
@@ -205,6 +257,15 @@ collection.data.update(uuid=vector_id, properties=existing_payload, vector=vector)
def get(self, vector_id):
+ """
+ Retrieve a vector by ID.
+
+ Args:
+ vector_id: ID of the vector to retrieve.
+
+ Returns:
+ dict: Retrieved vector and metadata.
+ """
vector_id = get_valid_uuid(vector_id)
collection = self.client.collections.get(str(self.collection_name))
@@ -225,21 +286,37 @@ return results
def list_cols(self):
+ """
+ List all collections.
+
+ Returns:
+ list: List of collection names.
+ """
collections = self.client.collections.list_all()
logger.debug(f"collections: {collections}")
print(f"collections: {collections}")
return {"collections": [{"name": col.name} for col in collections]}
def delete_col(self):
+ """Delete a collection."""
self.client.collections.delete(self.collection_name)
def col_info(self):
+ """
+ Get information about a collection.
+
+ Returns:
+ dict: Collection information.
+ """
schema = self.client.collections.get(self.collection_name)
if schema:
return schema
return None
def list(self, filters=None, limit=100) -> List[OutputData]:
+ """
+ List all vectors in a collection.
+ """
collection = self.client.collections.get(self.collection_name)
filter_conditions = []
if filters:
@@ -260,6 +337,7 @@ return [results]
def reset(self):
+ """Reset the index by deleting and recreating it."""
logger.warning(f"Resetting index {self.collection_name}...")
self.delete_col()
- self.create_col()+ self.create_col()
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/vector_stores/weaviate.py |
Write Python docstrings for this snippet | from typing import Tuple
from app.models import App, User
from sqlalchemy.orm import Session
def get_or_create_user(db: Session, user_id: str) -> User:
user = db.query(User).filter(User.user_id == user_id).first()
if not user:
user = User(user_id=user_id)
db.add(user)
db.commit()
db.refresh(user)
return user
def get_or_create_app(db: Session, user: User, app_id: str) -> App:
app = db.query(App).filter(App.owner_id == user.id, App.name == app_id).first()
if not app:
app = App(owner_id=user.id, name=app_id)
db.add(app)
db.commit()
db.refresh(app)
return app
def get_user_and_app(db: Session, user_id: str, app_id: str) -> Tuple[User, App]:
user = get_or_create_user(db, user_id)
app = get_or_create_app(db, user, app_id)
return user, app | --- +++ @@ -5,6 +5,7 @@
def get_or_create_user(db: Session, user_id: str) -> User:
+ """Get or create a user with the given user_id"""
user = db.query(User).filter(User.user_id == user_id).first()
if not user:
user = User(user_id=user_id)
@@ -15,6 +16,7 @@
def get_or_create_app(db: Session, user: User, app_id: str) -> App:
+ """Get or create an app for the given user"""
app = db.query(App).filter(App.owner_id == user.id, App.name == app_id).first()
if not app:
app = App(owner_id=user.id, name=app_id)
@@ -25,6 +27,7 @@
def get_user_and_app(db: Session, user_id: str, app_id: str) -> Tuple[User, App]:
+ """Get or create both user and their app"""
user = get_or_create_user(db, user_id)
app = get_or_create_app(db, user, app_id)
- return user, app+ return user, app
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/openmemory/api/app/utils/db.py |
Generate consistent documentation across files | from typing import Any, Dict, Optional
from app.database import get_db
from app.models import Config as ConfigModel
from app.utils.memory import reset_memory_client
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from sqlalchemy.orm import Session
router = APIRouter(prefix="/api/v1/config", tags=["config"])
class LLMConfig(BaseModel):
model: str = Field(..., description="LLM model name")
temperature: float = Field(..., description="Temperature setting for the model")
max_tokens: int = Field(..., description="Maximum tokens to generate")
api_key: Optional[str] = Field(None, description="API key or 'env:API_KEY' to use environment variable")
ollama_base_url: Optional[str] = Field(None, description="Base URL for Ollama server (e.g., http://host.docker.internal:11434)")
class LLMProvider(BaseModel):
provider: str = Field(..., description="LLM provider name")
config: LLMConfig
class EmbedderConfig(BaseModel):
model: str = Field(..., description="Embedder model name")
api_key: Optional[str] = Field(None, description="API key or 'env:API_KEY' to use environment variable")
ollama_base_url: Optional[str] = Field(None, description="Base URL for Ollama server (e.g., http://host.docker.internal:11434)")
class EmbedderProvider(BaseModel):
provider: str = Field(..., description="Embedder provider name")
config: EmbedderConfig
class VectorStoreProvider(BaseModel):
provider: str = Field(..., description="Vector store provider name")
# Below config can vary widely based on the vector store used. Refer https://docs.mem0.ai/components/vectordbs/config
config: Dict[str, Any] = Field(..., description="Vector store-specific configuration")
class OpenMemoryConfig(BaseModel):
custom_instructions: Optional[str] = Field(None, description="Custom instructions for memory management and fact extraction")
class Mem0Config(BaseModel):
llm: Optional[LLMProvider] = None
embedder: Optional[EmbedderProvider] = None
vector_store: Optional[VectorStoreProvider] = None
class ConfigSchema(BaseModel):
openmemory: Optional[OpenMemoryConfig] = None
mem0: Optional[Mem0Config] = None
def get_default_configuration():
return {
"openmemory": {
"custom_instructions": None
},
"mem0": {
"llm": {
"provider": "openai",
"config": {
"model": "gpt-4o-mini",
"temperature": 0.1,
"max_tokens": 2000,
"api_key": "env:OPENAI_API_KEY"
}
},
"embedder": {
"provider": "openai",
"config": {
"model": "text-embedding-3-small",
"api_key": "env:OPENAI_API_KEY"
}
},
"vector_store": None
}
}
def get_config_from_db(db: Session, key: str = "main"):
config = db.query(ConfigModel).filter(ConfigModel.key == key).first()
if not config:
# Create default config with proper provider configurations
default_config = get_default_configuration()
db_config = ConfigModel(key=key, value=default_config)
db.add(db_config)
db.commit()
db.refresh(db_config)
return default_config
# Ensure the config has all required sections with defaults
config_value = config.value
default_config = get_default_configuration()
# Merge with defaults to ensure all required fields exist
if "openmemory" not in config_value:
config_value["openmemory"] = default_config["openmemory"]
if "mem0" not in config_value:
config_value["mem0"] = default_config["mem0"]
else:
# Ensure LLM config exists with defaults
if "llm" not in config_value["mem0"] or config_value["mem0"]["llm"] is None:
config_value["mem0"]["llm"] = default_config["mem0"]["llm"]
# Ensure embedder config exists with defaults
if "embedder" not in config_value["mem0"] or config_value["mem0"]["embedder"] is None:
config_value["mem0"]["embedder"] = default_config["mem0"]["embedder"]
# Ensure vector_store config exists with defaults
if "vector_store" not in config_value["mem0"]:
config_value["mem0"]["vector_store"] = default_config["mem0"]["vector_store"]
# Save the updated config back to database if it was modified
if config_value != config.value:
config.value = config_value
db.commit()
db.refresh(config)
return config_value
def save_config_to_db(db: Session, config: Dict[str, Any], key: str = "main"):
db_config = db.query(ConfigModel).filter(ConfigModel.key == key).first()
if db_config:
db_config.value = config
db_config.updated_at = None # Will trigger the onupdate to set current time
else:
db_config = ConfigModel(key=key, value=config)
db.add(db_config)
db.commit()
db.refresh(db_config)
return db_config.value
@router.get("/", response_model=ConfigSchema)
async def get_configuration(db: Session = Depends(get_db)):
config = get_config_from_db(db)
return config
@router.put("/", response_model=ConfigSchema)
async def update_configuration(config: ConfigSchema, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
# Convert to dict for processing
updated_config = current_config.copy()
# Update openmemory settings if provided
if config.openmemory is not None:
if "openmemory" not in updated_config:
updated_config["openmemory"] = {}
updated_config["openmemory"].update(config.openmemory.dict(exclude_none=True))
# Update mem0 settings
updated_config["mem0"] = config.mem0.dict(exclude_none=True)
@router.patch("/", response_model=ConfigSchema)
async def patch_configuration(config_update: ConfigSchema, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
def deep_update(source, overrides):
for key, value in overrides.items():
if isinstance(value, dict) and key in source and isinstance(source[key], dict):
source[key] = deep_update(source[key], value)
else:
source[key] = value
return source
update_data = config_update.dict(exclude_unset=True)
updated_config = deep_update(current_config, update_data)
save_config_to_db(db, updated_config)
reset_memory_client()
return updated_config
@router.post("/reset", response_model=ConfigSchema)
async def reset_configuration(db: Session = Depends(get_db)):
try:
# Get the default configuration with proper provider setups
default_config = get_default_configuration()
# Save it as the current configuration in the database
save_config_to_db(db, default_config)
reset_memory_client()
return default_config
except Exception as e:
raise HTTPException(
status_code=500,
detail=f"Failed to reset configuration: {str(e)}"
)
@router.get("/mem0/llm", response_model=LLMProvider)
async def get_llm_configuration(db: Session = Depends(get_db)):
config = get_config_from_db(db)
llm_config = config.get("mem0", {}).get("llm", {})
return llm_config
@router.put("/mem0/llm", response_model=LLMProvider)
async def update_llm_configuration(llm_config: LLMProvider, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
# Ensure mem0 key exists
if "mem0" not in current_config:
current_config["mem0"] = {}
# Update the LLM configuration
current_config["mem0"]["llm"] = llm_config.dict(exclude_none=True)
# Save the configuration to database
save_config_to_db(db, current_config)
reset_memory_client()
return current_config["mem0"]["llm"]
@router.get("/mem0/embedder", response_model=EmbedderProvider)
async def get_embedder_configuration(db: Session = Depends(get_db)):
config = get_config_from_db(db)
embedder_config = config.get("mem0", {}).get("embedder", {})
return embedder_config
@router.put("/mem0/embedder", response_model=EmbedderProvider)
async def update_embedder_configuration(embedder_config: EmbedderProvider, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
# Ensure mem0 key exists
if "mem0" not in current_config:
current_config["mem0"] = {}
# Update the Embedder configuration
current_config["mem0"]["embedder"] = embedder_config.dict(exclude_none=True)
# Save the configuration to database
save_config_to_db(db, current_config)
reset_memory_client()
return current_config["mem0"]["embedder"]
@router.get("/mem0/vector_store", response_model=Optional[VectorStoreProvider])
async def get_vector_store_configuration(db: Session = Depends(get_db)):
config = get_config_from_db(db)
vector_store_config = config.get("mem0", {}).get("vector_store", None)
return vector_store_config
@router.put("/mem0/vector_store", response_model=VectorStoreProvider)
async def update_vector_store_configuration(vector_store_config: VectorStoreProvider, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
# Ensure mem0 key exists
if "mem0" not in current_config:
current_config["mem0"] = {}
# Update the Vector Store configuration
current_config["mem0"]["vector_store"] = vector_store_config.dict(exclude_none=True)
# Save the configuration to database
save_config_to_db(db, current_config)
reset_memory_client()
return current_config["mem0"]["vector_store"]
@router.get("/openmemory", response_model=OpenMemoryConfig)
async def get_openmemory_configuration(db: Session = Depends(get_db)):
config = get_config_from_db(db)
openmemory_config = config.get("openmemory", {})
return openmemory_config
@router.put("/openmemory", response_model=OpenMemoryConfig)
async def update_openmemory_configuration(openmemory_config: OpenMemoryConfig, db: Session = Depends(get_db)):
current_config = get_config_from_db(db)
# Ensure openmemory key exists
if "openmemory" not in current_config:
current_config["openmemory"] = {}
# Update the OpenMemory configuration
current_config["openmemory"].update(openmemory_config.dict(exclude_none=True))
# Save the configuration to database
save_config_to_db(db, current_config)
reset_memory_client()
return current_config["openmemory"] | --- +++ @@ -47,6 +47,7 @@ mem0: Optional[Mem0Config] = None
def get_default_configuration():
+ """Get the default configuration with sensible defaults for LLM and embedder."""
return {
"openmemory": {
"custom_instructions": None
@@ -73,6 +74,7 @@ }
def get_config_from_db(db: Session, key: str = "main"):
+ """Get configuration from database."""
config = db.query(ConfigModel).filter(ConfigModel.key == key).first()
if not config:
@@ -116,6 +118,7 @@ return config_value
def save_config_to_db(db: Session, config: Dict[str, Any], key: str = "main"):
+ """Save configuration to database."""
db_config = db.query(ConfigModel).filter(ConfigModel.key == key).first()
if db_config:
@@ -131,11 +134,13 @@
@router.get("/", response_model=ConfigSchema)
async def get_configuration(db: Session = Depends(get_db)):
+ """Get the current configuration."""
config = get_config_from_db(db)
return config
@router.put("/", response_model=ConfigSchema)
async def update_configuration(config: ConfigSchema, db: Session = Depends(get_db)):
+ """Update the configuration."""
current_config = get_config_from_db(db)
# Convert to dict for processing
@@ -153,6 +158,7 @@
@router.patch("/", response_model=ConfigSchema)
async def patch_configuration(config_update: ConfigSchema, db: Session = Depends(get_db)):
+ """Update parts of the configuration."""
current_config = get_config_from_db(db)
def deep_update(source, overrides):
@@ -173,6 +179,7 @@
@router.post("/reset", response_model=ConfigSchema)
async def reset_configuration(db: Session = Depends(get_db)):
+ """Reset the configuration to default values."""
try:
# Get the default configuration with proper provider setups
default_config = get_default_configuration()
@@ -189,12 +196,14 @@
@router.get("/mem0/llm", response_model=LLMProvider)
async def get_llm_configuration(db: Session = Depends(get_db)):
+ """Get only the LLM configuration."""
config = get_config_from_db(db)
llm_config = config.get("mem0", {}).get("llm", {})
return llm_config
@router.put("/mem0/llm", response_model=LLMProvider)
async def update_llm_configuration(llm_config: LLMProvider, db: Session = Depends(get_db)):
+ """Update only the LLM configuration."""
current_config = get_config_from_db(db)
# Ensure mem0 key exists
@@ -211,12 +220,14 @@
@router.get("/mem0/embedder", response_model=EmbedderProvider)
async def get_embedder_configuration(db: Session = Depends(get_db)):
+ """Get only the Embedder configuration."""
config = get_config_from_db(db)
embedder_config = config.get("mem0", {}).get("embedder", {})
return embedder_config
@router.put("/mem0/embedder", response_model=EmbedderProvider)
async def update_embedder_configuration(embedder_config: EmbedderProvider, db: Session = Depends(get_db)):
+ """Update only the Embedder configuration."""
current_config = get_config_from_db(db)
# Ensure mem0 key exists
@@ -233,12 +244,14 @@
@router.get("/mem0/vector_store", response_model=Optional[VectorStoreProvider])
async def get_vector_store_configuration(db: Session = Depends(get_db)):
+ """Get only the Vector Store configuration."""
config = get_config_from_db(db)
vector_store_config = config.get("mem0", {}).get("vector_store", None)
return vector_store_config
@router.put("/mem0/vector_store", response_model=VectorStoreProvider)
async def update_vector_store_configuration(vector_store_config: VectorStoreProvider, db: Session = Depends(get_db)):
+ """Update only the Vector Store configuration."""
current_config = get_config_from_db(db)
# Ensure mem0 key exists
@@ -255,12 +268,14 @@
@router.get("/openmemory", response_model=OpenMemoryConfig)
async def get_openmemory_configuration(db: Session = Depends(get_db)):
+ """Get only the OpenMemory configuration."""
config = get_config_from_db(db)
openmemory_config = config.get("openmemory", {})
return openmemory_config
@router.put("/openmemory", response_model=OpenMemoryConfig)
async def update_openmemory_configuration(openmemory_config: OpenMemoryConfig, db: Session = Depends(get_db)):
+ """Update only the OpenMemory configuration."""
current_config = get_config_from_db(db)
# Ensure openmemory key exists
@@ -273,4 +288,4 @@ # Save the configuration to database
save_config_to_db(db, current_config)
reset_memory_client()
- return current_config["openmemory"]+ return current_config["openmemory"]
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/openmemory/api/app/routers/config.py |
Fully document this Python code with docstrings | import logging
from abc import ABC, abstractmethod
from mem0.memory.utils import format_entities
try:
from rank_bm25 import BM25Okapi
except ImportError:
raise ImportError("rank_bm25 is not installed. Please install it using pip install rank-bm25")
from mem0.graphs.tools import (
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
DELETE_MEMORY_TOOL_GRAPH,
EXTRACT_ENTITIES_STRUCT_TOOL,
EXTRACT_ENTITIES_TOOL,
RELATIONS_STRUCT_TOOL,
RELATIONS_TOOL,
)
from mem0.graphs.utils import EXTRACT_RELATIONS_PROMPT, get_delete_messages
from mem0.utils.factory import EmbedderFactory, LlmFactory, VectorStoreFactory
logger = logging.getLogger(__name__)
class NeptuneBase(ABC):
@staticmethod
def _create_embedding_model(config):
return EmbedderFactory.create(
config.embedder.provider,
config.embedder.config,
{"enable_embeddings": True},
)
@staticmethod
def _create_llm(config, llm_provider):
return LlmFactory.create(llm_provider, config.llm.config)
@staticmethod
def _create_vector_store(vector_store_provider, config):
return VectorStoreFactory.create(vector_store_provider, config.vector_store.config)
def add(self, data, filters):
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
to_be_deleted = self._get_delete_entities_from_search_output(search_output, data, filters)
deleted_entities = self._delete_entities(to_be_deleted, filters["user_id"])
added_entities = self._add_entities(to_be_added, filters["user_id"], entity_type_map)
return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def _retrieve_nodes_from_data(self, data, filters):
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
search_results = self.llm.generate_response(
messages=[
{
"role": "system",
"content": f"You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use {filters['user_id']} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question.",
},
{"role": "user", "content": data},
],
tools=_tools,
)
entity_type_map = {}
try:
for tool_call in search_results["tool_calls"]:
if tool_call["name"] != "extract_entities":
continue
for item in tool_call.get("arguments", {}).get("entities", []):
entity_type_map[item["entity"]] = item["entity_type"]
except Exception as e:
logger.exception(
f"Error in search tool: {e}, llm_provider={self.llm_provider}, search_results={search_results}"
)
entity_type_map = {k.lower().replace(" ", "_"): v.lower().replace(" ", "_") for k, v in entity_type_map.items()}
return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
if self.config.graph_store.custom_prompt:
messages = [
{
"role": "system",
"content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]).replace(
"CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}"
),
},
{"role": "user", "content": data},
]
else:
messages = [
{
"role": "system",
"content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]),
},
{
"role": "user",
"content": f"List of entities: {list(entity_type_map.keys())}. \n\nText: {data}",
},
]
_tools = [RELATIONS_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [RELATIONS_STRUCT_TOOL]
extracted_entities = self.llm.generate_response(
messages=messages,
tools=_tools,
)
entities = []
if extracted_entities["tool_calls"]:
entities = extracted_entities["tool_calls"][0].get("arguments", {}).get("entities", [])
entities = self._remove_spaces_from_entities(entities)
logger.debug(f"Extracted entities: {entities}")
return entities
def _remove_spaces_from_entities(self, entity_list):
for item in entity_list:
item["source"] = item["source"].lower().replace(" ", "_")
item["relationship"] = item["relationship"].lower().replace(" ", "_")
item["destination"] = item["destination"].lower().replace(" ", "_")
return entity_list
def _get_delete_entities_from_search_output(self, search_output, data, filters):
search_output_string = format_entities(search_output)
system_prompt, user_prompt = get_delete_messages(search_output_string, data, filters["user_id"])
_tools = [DELETE_MEMORY_TOOL_GRAPH]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
]
memory_updates = self.llm.generate_response(
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
tools=_tools,
)
to_be_deleted = []
for item in memory_updates["tool_calls"]:
if item["name"] == "delete_graph_memory":
to_be_deleted.append(item["arguments"])
# in case if it is not in the correct format
to_be_deleted = self._remove_spaces_from_entities(to_be_deleted)
logger.debug(f"Deleted relationships: {to_be_deleted}")
return to_be_deleted
def _delete_entities(self, to_be_deleted, user_id):
results = []
for item in to_be_deleted:
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# Delete the specific relationship between nodes
cypher, params = self._delete_entities_cypher(source, destination, relationship, user_id)
result = self.graph.query(cypher, params=params)
results.append(result)
return results
@abstractmethod
def _delete_entities_cypher(self, source, destination, relationship, user_id):
pass
def _add_entities(self, to_be_added, user_id, entity_type_map):
results = []
for item in to_be_added:
# entities
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# types
source_type = entity_type_map.get(source, "__User__")
destination_type = entity_type_map.get(destination, "__User__")
# embeddings
source_embedding = self.embedding_model.embed(source)
dest_embedding = self.embedding_model.embed(destination)
# search for the nodes with the closest embeddings
source_node_search_result = self._search_source_node(source_embedding, user_id, threshold=self.threshold)
destination_node_search_result = self._search_destination_node(dest_embedding, user_id, threshold=self.threshold)
cypher, params = self._add_entities_cypher(
source_node_search_result,
source,
source_embedding,
source_type,
destination_node_search_result,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
)
result = self.graph.query(cypher, params=params)
results.append(result)
return results
def _add_entities_cypher(
self,
source_node_list,
source,
source_embedding,
source_type,
destination_node_list,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
):
if not destination_node_list and source_node_list:
return self._add_entities_by_source_cypher(
source_node_list,
destination,
dest_embedding,
destination_type,
relationship,
user_id)
elif destination_node_list and not source_node_list:
return self._add_entities_by_destination_cypher(
source,
source_embedding,
source_type,
destination_node_list,
relationship,
user_id)
elif source_node_list and destination_node_list:
return self._add_relationship_entities_cypher(
source_node_list,
destination_node_list,
relationship,
user_id)
# else source_node_list and destination_node_list are empty
return self._add_new_entities_cypher(
source,
source_embedding,
source_type,
destination,
dest_embedding,
destination_type,
relationship,
user_id)
@abstractmethod
def _add_entities_by_source_cypher(
self,
source_node_list,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
):
pass
@abstractmethod
def _add_entities_by_destination_cypher(
self,
source,
source_embedding,
source_type,
destination_node_list,
relationship,
user_id,
):
pass
@abstractmethod
def _add_relationship_entities_cypher(
self,
source_node_list,
destination_node_list,
relationship,
user_id,
):
pass
@abstractmethod
def _add_new_entities_cypher(
self,
source,
source_embedding,
source_type,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
):
pass
def search(self, query, filters, limit=100):
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
if not search_output:
return []
search_outputs_sequence = [
[item["source"], item["relationship"], item["destination"]] for item in search_output
]
bm25 = BM25Okapi(search_outputs_sequence)
tokenized_query = query.split(" ")
reranked_results = bm25.get_top_n(tokenized_query, search_outputs_sequence, n=5)
search_results = []
for item in reranked_results:
search_results.append({"source": item[0], "relationship": item[1], "destination": item[2]})
return search_results
def _search_source_node(self, source_embedding, user_id, threshold=0.9):
cypher, params = self._search_source_node_cypher(source_embedding, user_id, threshold)
result = self.graph.query(cypher, params=params)
return result
@abstractmethod
def _search_source_node_cypher(self, source_embedding, user_id, threshold):
pass
def _search_destination_node(self, destination_embedding, user_id, threshold=0.9):
cypher, params = self._search_destination_node_cypher(destination_embedding, user_id, threshold)
result = self.graph.query(cypher, params=params)
return result
@abstractmethod
def _search_destination_node_cypher(self, destination_embedding, user_id, threshold):
pass
def delete_all(self, filters):
cypher, params = self._delete_all_cypher(filters)
self.graph.query(cypher, params=params)
@abstractmethod
def _delete_all_cypher(self, filters):
pass
def get_all(self, filters, limit=100):
# return all nodes and relationships
query, params = self._get_all_cypher(filters, limit)
results = self.graph.query(query, params=params)
final_results = []
for result in results:
final_results.append(
{
"source": result["source"],
"relationship": result["relationship"],
"target": result["target"],
}
)
logger.debug(f"Retrieved {len(final_results)} relationships")
return final_results
@abstractmethod
def _get_all_cypher(self, filters, limit):
pass
def _search_graph_db(self, node_list, filters, limit=100):
result_relations = []
for node in node_list:
n_embedding = self.embedding_model.embed(node)
cypher_query, params = self._search_graph_db_cypher(n_embedding, filters, limit)
ans = self.graph.query(cypher_query, params=params)
result_relations.extend(ans)
return result_relations
@abstractmethod
def _search_graph_db_cypher(self, n_embedding, filters, limit):
pass
# Reset is not defined in base.py
def reset(self):
logger.warning("Clearing graph...")
graph_id = self.graph.graph_identifier
self.graph.client.reset_graph(
graphIdentifier=graph_id,
skipSnapshot=True,
)
waiter = self.graph.client.get_waiter("graph_available")
waiter.wait(graphIdentifier=graph_id, WaiterConfig={"Delay": 10, "MaxAttempts": 60}) | --- +++ @@ -23,9 +23,16 @@
class NeptuneBase(ABC):
+ """
+ Abstract base class for neptune (neptune analytics and neptune db) calls using OpenCypher
+ to store/retrieve data
+ """
@staticmethod
def _create_embedding_model(config):
+ """
+ :return: the Embedder model used for memory store
+ """
return EmbedderFactory.create(
config.embedder.provider,
config.embedder.config,
@@ -34,13 +41,28 @@
@staticmethod
def _create_llm(config, llm_provider):
+ """
+ :return: the llm model used for memory store
+ """
return LlmFactory.create(llm_provider, config.llm.config)
@staticmethod
def _create_vector_store(vector_store_provider, config):
+ """
+ :param vector_store_provider: name of vector store
+ :param config: the vector_store configuration
+ :return:
+ """
return VectorStoreFactory.create(vector_store_provider, config.vector_store.config)
def add(self, data, filters):
+ """
+ Adds data to the graph.
+
+ Args:
+ data (str): The data to add to the graph.
+ filters (dict): A dictionary containing filters to be applied during the addition.
+ """
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -52,6 +74,9 @@ return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def _retrieve_nodes_from_data(self, data, filters):
+ """
+ Extract all entities mentioned in the query.
+ """
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
@@ -83,6 +108,9 @@ return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
+ """
+ Establish relations among the extracted nodes.
+ """
if self.config.graph_store.custom_prompt:
messages = [
{
@@ -130,6 +158,9 @@ return entity_list
def _get_delete_entities_from_search_output(self, search_output, data, filters):
+ """
+ Get the entities to be deleted from the search output.
+ """
search_output_string = format_entities(search_output)
system_prompt, user_prompt = get_delete_messages(search_output_string, data, filters["user_id"])
@@ -158,6 +189,9 @@ return to_be_deleted
def _delete_entities(self, to_be_deleted, user_id):
+ """
+ Delete the entities from the graph.
+ """
results = []
for item in to_be_deleted:
@@ -173,10 +207,16 @@
@abstractmethod
def _delete_entities_cypher(self, source, destination, relationship, user_id):
+ """
+ Returns the OpenCypher query and parameters for deleting entities in the graph DB
+ """
pass
def _add_entities(self, to_be_added, user_id, entity_type_map):
+ """
+ Add the new entities to the graph. Merge the nodes if they already exist.
+ """
results = []
for item in to_be_added:
@@ -226,6 +266,9 @@ relationship,
user_id,
):
+ """
+ Returns the OpenCypher query and parameters for adding entities in the graph DB
+ """
if not destination_node_list and source_node_list:
return self._add_entities_by_source_cypher(
source_node_list,
@@ -308,6 +351,19 @@ pass
def search(self, query, filters, limit=100):
+ """
+ Search for memories and related graph data.
+
+ Args:
+ query (str): Query to search for.
+ filters (dict): A dictionary containing filters to be applied during the search.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing:
+ - "contexts": List of search results from the base data store.
+ - "entities": List of related graph data based on the query.
+ """
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -336,6 +392,9 @@
@abstractmethod
def _search_source_node_cypher(self, source_embedding, user_id, threshold):
+ """
+ Returns the OpenCypher query and parameters to search for source nodes
+ """
pass
def _search_destination_node(self, destination_embedding, user_id, threshold=0.9):
@@ -345,6 +404,9 @@
@abstractmethod
def _search_destination_node_cypher(self, destination_embedding, user_id, threshold):
+ """
+ Returns the OpenCypher query and parameters to search for destination nodes
+ """
pass
def delete_all(self, filters):
@@ -353,9 +415,23 @@
@abstractmethod
def _delete_all_cypher(self, filters):
+ """
+ Returns the OpenCypher query and parameters to delete all edges/nodes in the memory store
+ """
pass
def get_all(self, filters, limit=100):
+ """
+ Retrieves all nodes and relationships from the graph database based on filtering criteria.
+
+ Args:
+ filters (dict): A dictionary containing filters to be applied during the retrieval.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+ Returns:
+ list: A list of dictionaries, each containing:
+ - 'contexts': The base data store response for each memory.
+ - 'entities': A list of strings representing the nodes and relationships
+ """
# return all nodes and relationships
query, params = self._get_all_cypher(filters, limit)
@@ -377,9 +453,15 @@
@abstractmethod
def _get_all_cypher(self, filters, limit):
+ """
+ Returns the OpenCypher query and parameters to get all edges/nodes in the memory store
+ """
pass
def _search_graph_db(self, node_list, filters, limit=100):
+ """
+ Search similar nodes among and their respective incoming and outgoing relations.
+ """
result_relations = []
for node in node_list:
@@ -392,10 +474,18 @@
@abstractmethod
def _search_graph_db_cypher(self, n_embedding, filters, limit):
+ """
+ Returns the OpenCypher query and parameters to search for similar nodes in the memory store
+ """
pass
# Reset is not defined in base.py
def reset(self):
+ """
+ Reset the graph by clearing all nodes and relationships.
+
+ link: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/neptune-graph/client/reset_graph.html
+ """
logger.warning("Clearing graph...")
graph_id = self.graph.graph_identifier
@@ -404,4 +494,4 @@ skipSnapshot=True,
)
waiter = self.graph.client.get_waiter("graph_available")
- waiter.wait(graphIdentifier=graph_id, WaiterConfig={"Delay": 10, "MaxAttempts": 60})+ waiter.wait(graphIdentifier=graph_id, WaiterConfig={"Delay": 10, "MaxAttempts": 60})
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/graphs/neptune/base.py |
Add standardized docstrings across the file | import logging
import uuid
from typing import List, Optional
from pydantic import BaseModel
try:
import vecs
except ImportError:
raise ImportError("The 'vecs' library is required. Please install it using 'pip install vecs'.")
from mem0.configs.vector_stores.supabase import IndexMeasure, IndexMethod
from mem0.vector_stores.base import VectorStoreBase
logger = logging.getLogger(__name__)
class OutputData(BaseModel):
id: Optional[str]
score: Optional[float]
payload: Optional[dict]
class Supabase(VectorStoreBase):
def __init__(
self,
connection_string: str,
collection_name: str,
embedding_model_dims: int,
index_method: IndexMethod = IndexMethod.AUTO,
index_measure: IndexMeasure = IndexMeasure.COSINE,
):
self.db = vecs.create_client(connection_string)
self.collection_name = collection_name
self.embedding_model_dims = embedding_model_dims
self.index_method = index_method
self.index_measure = index_measure
collections = self.list_cols()
if collection_name not in collections:
self.create_col(embedding_model_dims)
def _preprocess_filters(self, filters: Optional[dict] = None) -> Optional[dict]:
if filters is None:
return None
if len(filters) == 1:
# For single filter, keep the simple format
key, value = next(iter(filters.items()))
return {key: {"$eq": value}}
# For multiple filters, use $and clause
return {"$and": [{key: {"$eq": value}} for key, value in filters.items()]}
def create_col(self, embedding_model_dims: Optional[int] = None) -> None:
dims = embedding_model_dims or self.embedding_model_dims
if not dims:
raise ValueError(
"embedding_model_dims must be provided either during initialization or when creating collection"
)
logger.info(f"Creating new collection: {self.collection_name}")
try:
self.collection = self.db.get_or_create_collection(name=self.collection_name, dimension=dims)
self.collection.create_index(method=self.index_method.value, measure=self.index_measure.value)
logger.info(f"Successfully created collection {self.collection_name} with dimension {dims}")
except Exception as e:
logger.error(f"Failed to create collection: {str(e)}")
raise
def insert(
self, vectors: List[List[float]], payloads: Optional[List[dict]] = None, ids: Optional[List[str]] = None
):
logger.info(f"Inserting {len(vectors)} vectors into collection {self.collection_name}")
if not ids:
ids = [str(uuid.uuid4()) for _ in vectors]
if not payloads:
payloads = [{} for _ in vectors]
records = [(id, vector, payload) for id, vector, payload in zip(ids, vectors, payloads)]
self.collection.upsert(records)
def search(
self, query: str, vectors: List[float], limit: int = 5, filters: Optional[dict] = None
) -> List[OutputData]:
filters = self._preprocess_filters(filters)
results = self.collection.query(
data=vectors, limit=limit, filters=filters, include_metadata=True, include_value=True
)
return [OutputData(id=str(result[0]), score=float(result[1]), payload=result[2]) for result in results]
def delete(self, vector_id: str):
self.collection.delete([(vector_id,)])
def update(self, vector_id: str, vector: Optional[List[float]] = None, payload: Optional[dict] = None):
if vector is None:
# If only updating metadata, we need to get the existing vector
existing = self.get(vector_id)
if existing and existing.payload:
vector = existing.payload.get("vector", [])
if vector:
self.collection.upsert([(vector_id, vector, payload or {})])
def get(self, vector_id: str) -> Optional[OutputData]:
result = self.collection.fetch([(vector_id,)])
if not result:
return []
record = result[0]
return OutputData(id=str(record.id), score=None, payload=record.metadata)
def list_cols(self) -> List[str]:
return self.db.list_collections()
def delete_col(self):
self.db.delete_collection(self.collection_name)
def col_info(self) -> dict:
info = self.collection.describe()
return {
"name": info.name,
"count": info.vectors,
"dimension": info.dimension,
"index": {"method": info.index_method, "metric": info.distance_metric},
}
def list(self, filters: Optional[dict] = None, limit: int = 100) -> List[OutputData]:
filters = self._preprocess_filters(filters)
query = [0] * self.embedding_model_dims
ids = self.collection.query(
data=query, limit=limit, filters=filters, include_metadata=True, include_value=False
)
ids = [id[0] for id in ids]
records = self.collection.fetch(ids=ids)
return [[OutputData(id=str(record[0]), score=None, payload=record[2]) for record in records]]
def reset(self):
logger.warning(f"Resetting index {self.collection_name}...")
self.delete_col()
self.create_col(self.embedding_model_dims) | --- +++ @@ -30,6 +30,16 @@ index_method: IndexMethod = IndexMethod.AUTO,
index_measure: IndexMeasure = IndexMeasure.COSINE,
):
+ """
+ Initialize the Supabase vector store using vecs.
+
+ Args:
+ connection_string (str): PostgreSQL connection string
+ collection_name (str): Collection name
+ embedding_model_dims (int): Dimension of the embedding vector
+ index_method (IndexMethod): Index method to use. Defaults to AUTO.
+ index_measure (IndexMeasure): Distance measure to use. Defaults to COSINE.
+ """
self.db = vecs.create_client(connection_string)
self.collection_name = collection_name
self.embedding_model_dims = embedding_model_dims
@@ -41,6 +51,13 @@ self.create_col(embedding_model_dims)
def _preprocess_filters(self, filters: Optional[dict] = None) -> Optional[dict]:
+ """
+ Preprocess filters to be compatible with vecs.
+
+ Args:
+ filters (Dict, optional): Filters to preprocess. Multiple filters will be
+ combined with AND logic.
+ """
if filters is None:
return None
@@ -53,6 +70,14 @@ return {"$and": [{key: {"$eq": value}} for key, value in filters.items()]}
def create_col(self, embedding_model_dims: Optional[int] = None) -> None:
+ """
+ Create a new collection with vector support.
+ Will also initialize vector search index.
+
+ Args:
+ embedding_model_dims (int, optional): Dimension of the embedding vector.
+ If not provided, uses the dimension specified in initialization.
+ """
dims = embedding_model_dims or self.embedding_model_dims
if not dims:
raise ValueError(
@@ -71,6 +96,14 @@ def insert(
self, vectors: List[List[float]], payloads: Optional[List[dict]] = None, ids: Optional[List[str]] = None
):
+ """
+ Insert vectors into the collection.
+
+ Args:
+ vectors (List[List[float]]): List of vectors to insert
+ payloads (List[Dict], optional): List of payloads corresponding to vectors
+ ids (List[str], optional): List of IDs corresponding to vectors
+ """
logger.info(f"Inserting {len(vectors)} vectors into collection {self.collection_name}")
if not ids:
@@ -85,6 +118,18 @@ def search(
self, query: str, vectors: List[float], limit: int = 5, filters: Optional[dict] = None
) -> List[OutputData]:
+ """
+ Search for similar vectors.
+
+ Args:
+ query (str): Query.
+ vectors (List[float]): Query vector.
+ limit (int, optional): Number of results to return. Defaults to 5.
+ filters (Dict, optional): Filters to apply to the search. Defaults to None.
+
+ Returns:
+ List[OutputData]: Search results
+ """
filters = self._preprocess_filters(filters)
results = self.collection.query(
data=vectors, limit=limit, filters=filters, include_metadata=True, include_value=True
@@ -93,9 +138,23 @@ return [OutputData(id=str(result[0]), score=float(result[1]), payload=result[2]) for result in results]
def delete(self, vector_id: str):
+ """
+ Delete a vector by ID.
+
+ Args:
+ vector_id (str): ID of the vector to delete
+ """
self.collection.delete([(vector_id,)])
def update(self, vector_id: str, vector: Optional[List[float]] = None, payload: Optional[dict] = None):
+ """
+ Update a vector and/or its payload.
+
+ Args:
+ vector_id (str): ID of the vector to update
+ vector (List[float], optional): Updated vector
+ payload (Dict, optional): Updated payload
+ """
if vector is None:
# If only updating metadata, we need to get the existing vector
existing = self.get(vector_id)
@@ -106,6 +165,15 @@ self.collection.upsert([(vector_id, vector, payload or {})])
def get(self, vector_id: str) -> Optional[OutputData]:
+ """
+ Retrieve a vector by ID.
+
+ Args:
+ vector_id (str): ID of the vector to retrieve
+
+ Returns:
+ Optional[OutputData]: Retrieved vector data or None if not found
+ """
result = self.collection.fetch([(vector_id,)])
if not result:
return []
@@ -114,12 +182,25 @@ return OutputData(id=str(record.id), score=None, payload=record.metadata)
def list_cols(self) -> List[str]:
+ """
+ List all collections.
+
+ Returns:
+ List[str]: List of collection names
+ """
return self.db.list_collections()
def delete_col(self):
+ """Delete the collection."""
self.db.delete_collection(self.collection_name)
def col_info(self) -> dict:
+ """
+ Get information about the collection.
+
+ Returns:
+ Dict: Collection information including name and configuration
+ """
info = self.collection.describe()
return {
"name": info.name,
@@ -129,6 +210,16 @@ }
def list(self, filters: Optional[dict] = None, limit: int = 100) -> List[OutputData]:
+ """
+ List vectors in the collection.
+
+ Args:
+ filters (Dict, optional): Filters to apply
+ limit (int, optional): Maximum number of results to return. Defaults to 100.
+
+ Returns:
+ List[OutputData]: List of vectors
+ """
filters = self._preprocess_filters(filters)
query = [0] * self.embedding_model_dims
ids = self.collection.query(
@@ -140,6 +231,7 @@ return [[OutputData(id=str(record[0]), score=None, payload=record[2]) for record in records]]
def reset(self):
+ """Reset the index by deleting and recreating it."""
logger.warning(f"Resetting index {self.collection_name}...")
self.delete_col()
- self.create_col(self.embedding_model_dims)+ self.create_col(self.embedding_model_dims)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/vector_stores/supabase.py |
Write docstrings that follow conventions | import os
from typing import Dict, List, Optional
try:
from google import genai
from google.genai import types
except ImportError:
raise ImportError("The 'google-genai' library is required. Please install it using 'pip install google-genai'.")
from mem0.configs.llms.base import BaseLlmConfig
from mem0.llms.base import LLMBase
class GeminiLLM(LLMBase):
def __init__(self, config: Optional[BaseLlmConfig] = None):
super().__init__(config)
if not self.config.model:
self.config.model = "gemini-2.0-flash"
api_key = self.config.api_key or os.getenv("GOOGLE_API_KEY")
self.client = genai.Client(api_key=api_key)
def _parse_response(self, response, tools):
if tools:
processed_response = {
"content": None,
"tool_calls": [],
}
# Extract content from the first candidate
if response.candidates and response.candidates[0].content.parts:
for part in response.candidates[0].content.parts:
if hasattr(part, "text") and part.text:
processed_response["content"] = part.text
break
# Extract function calls
if response.candidates and response.candidates[0].content.parts:
for part in response.candidates[0].content.parts:
if hasattr(part, "function_call") and part.function_call:
fn = part.function_call
processed_response["tool_calls"].append(
{
"name": fn.name,
"arguments": dict(fn.args) if fn.args else {},
}
)
return processed_response
else:
if response.candidates and response.candidates[0].content.parts:
for part in response.candidates[0].content.parts:
if hasattr(part, "text") and part.text:
return part.text
return ""
def _reformat_messages(self, messages: List[Dict[str, str]]):
system_instruction = None
contents = []
for message in messages:
if message["role"] == "system":
system_instruction = message["content"]
else:
content = types.Content(
parts=[types.Part(text=message["content"])],
role=message["role"],
)
contents.append(content)
return system_instruction, contents
def _reformat_tools(self, tools: Optional[List[Dict]]):
def remove_additional_properties(data):
if isinstance(data, dict):
filtered_dict = {
key: remove_additional_properties(value)
for key, value in data.items()
if not (key == "additionalProperties")
}
return filtered_dict
else:
return data
if tools:
function_declarations = []
for tool in tools:
func = tool["function"].copy()
cleaned_func = remove_additional_properties(func)
function_declaration = types.FunctionDeclaration(
name=cleaned_func["name"],
description=cleaned_func.get("description", ""),
parameters=cleaned_func.get("parameters", {}),
)
function_declarations.append(function_declaration)
tool_obj = types.Tool(function_declarations=function_declarations)
return [tool_obj]
else:
return None
def generate_response(
self,
messages: List[Dict[str, str]],
response_format=None,
tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
# Extract system instruction and reformat messages
system_instruction, contents = self._reformat_messages(messages)
# Prepare generation config
config_params = {
"temperature": self.config.temperature,
"max_output_tokens": self.config.max_tokens,
"top_p": self.config.top_p,
}
# Add system instruction to config if present
if system_instruction:
config_params["system_instruction"] = system_instruction
if response_format is not None and response_format["type"] == "json_object":
config_params["response_mime_type"] = "application/json"
if "schema" in response_format:
config_params["response_schema"] = response_format["schema"]
if tools:
formatted_tools = self._reformat_tools(tools)
config_params["tools"] = formatted_tools
if tool_choice:
if tool_choice == "auto":
mode = types.FunctionCallingConfigMode.AUTO
elif tool_choice == "any":
mode = types.FunctionCallingConfigMode.ANY
else:
mode = types.FunctionCallingConfigMode.NONE
tool_config = types.ToolConfig(
function_calling_config=types.FunctionCallingConfig(
mode=mode,
allowed_function_names=(
[tool["function"]["name"] for tool in tools] if tool_choice == "any" else None
),
)
)
config_params["tool_config"] = tool_config
generation_config = types.GenerateContentConfig(**config_params)
response = self.client.models.generate_content(
model=self.config.model, contents=contents, config=generation_config
)
return self._parse_response(response, tools) | --- +++ @@ -22,6 +22,16 @@ self.client = genai.Client(api_key=api_key)
def _parse_response(self, response, tools):
+ """
+ Process the response based on whether tools are used or not.
+
+ Args:
+ response: The raw response from API.
+ tools: The list of tools provided in the request.
+
+ Returns:
+ str or dict: The processed response.
+ """
if tools:
processed_response = {
"content": None,
@@ -56,6 +66,15 @@ return ""
def _reformat_messages(self, messages: List[Dict[str, str]]):
+ """
+ Reformat messages for Gemini.
+
+ Args:
+ messages: The list of messages provided in the request.
+
+ Returns:
+ tuple: (system_instruction, contents_list)
+ """
system_instruction = None
contents = []
@@ -72,8 +91,18 @@ return system_instruction, contents
def _reformat_tools(self, tools: Optional[List[Dict]]):
+ """
+ Reformat tools for Gemini.
+
+ Args:
+ tools: The list of tools provided in the request.
+
+ Returns:
+ list: The list of tools in the required format.
+ """
def remove_additional_properties(data):
+ """Recursively removes 'additionalProperties' from nested dictionaries."""
if isinstance(data, dict):
filtered_dict = {
key: remove_additional_properties(value)
@@ -109,6 +138,18 @@ tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
+ """
+ Generate a response based on the given messages using Gemini.
+
+ Args:
+ messages (list): List of message dicts containing 'role' and 'content'.
+ response_format (str or object, optional): Format for the response. Defaults to "text".
+ tools (list, optional): List of tools that the model can call. Defaults to None.
+ tool_choice (str, optional): Tool choice method. Defaults to "auto".
+
+ Returns:
+ str: The generated response.
+ """
# Extract system instruction and reformat messages
system_instruction, contents = self._reformat_messages(messages)
@@ -157,4 +198,4 @@ model=self.config.model, contents=contents, config=generation_config
)
- return self._parse_response(response, tools)+ return self._parse_response(response, tools)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/llms/gemini.py |
Add return value explanations in docstrings | import logging
from mem0.memory.utils import format_entities
try:
import kuzu
except ImportError:
raise ImportError("kuzu is not installed. Please install it using pip install kuzu")
try:
from rank_bm25 import BM25Okapi
except ImportError:
raise ImportError("rank_bm25 is not installed. Please install it using pip install rank-bm25")
from mem0.graphs.tools import (
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
DELETE_MEMORY_TOOL_GRAPH,
EXTRACT_ENTITIES_STRUCT_TOOL,
EXTRACT_ENTITIES_TOOL,
RELATIONS_STRUCT_TOOL,
RELATIONS_TOOL,
)
from mem0.graphs.utils import EXTRACT_RELATIONS_PROMPT, get_delete_messages
from mem0.utils.factory import EmbedderFactory, LlmFactory
logger = logging.getLogger(__name__)
class MemoryGraph:
def __init__(self, config):
self.config = config
self.embedding_model = EmbedderFactory.create(
self.config.embedder.provider,
self.config.embedder.config,
self.config.vector_store.config,
)
self.embedding_dims = self.embedding_model.config.embedding_dims
if self.embedding_dims is None or self.embedding_dims <= 0:
raise ValueError(f"embedding_dims must be a positive integer. Given: {self.embedding_dims}")
self.db = kuzu.Database(self.config.graph_store.config.db)
self.graph = kuzu.Connection(self.db)
self.node_label = ":Entity"
self.rel_label = ":CONNECTED_TO"
self.kuzu_create_schema()
# Default to openai if no specific provider is configured
self.llm_provider = "openai"
if self.config.llm and self.config.llm.provider:
self.llm_provider = self.config.llm.provider
if self.config.graph_store and self.config.graph_store.llm and self.config.graph_store.llm.provider:
self.llm_provider = self.config.graph_store.llm.provider
# Get LLM config with proper null checks
llm_config = None
if self.config.graph_store and self.config.graph_store.llm and hasattr(self.config.graph_store.llm, "config"):
llm_config = self.config.graph_store.llm.config
elif hasattr(self.config.llm, "config"):
llm_config = self.config.llm.config
self.llm = LlmFactory.create(self.llm_provider, llm_config)
self.user_id = None
# Use threshold from graph_store config, default to 0.7 for backward compatibility
self.threshold = self.config.graph_store.threshold if hasattr(self.config.graph_store, 'threshold') else 0.7
def kuzu_create_schema(self):
self.kuzu_execute(
"""
CREATE NODE TABLE IF NOT EXISTS Entity(
id SERIAL PRIMARY KEY,
user_id STRING,
agent_id STRING,
run_id STRING,
name STRING,
mentions INT64,
created TIMESTAMP,
embedding FLOAT[]);
"""
)
self.kuzu_execute(
"""
CREATE REL TABLE IF NOT EXISTS CONNECTED_TO(
FROM Entity TO Entity,
name STRING,
mentions INT64,
created TIMESTAMP,
updated TIMESTAMP
);
"""
)
def kuzu_execute(self, query, parameters=None):
results = self.graph.execute(query, parameters)
return list(results.rows_as_dict())
def add(self, data, filters):
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
to_be_deleted = self._get_delete_entities_from_search_output(search_output, data, filters)
deleted_entities = self._delete_entities(to_be_deleted, filters)
added_entities = self._add_entities(to_be_added, filters, entity_type_map)
return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=5):
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
if not search_output:
return []
search_outputs_sequence = [
[item["source"], item["relationship"], item["destination"]] for item in search_output
]
bm25 = BM25Okapi(search_outputs_sequence)
tokenized_query = query.split(" ")
reranked_results = bm25.get_top_n(tokenized_query, search_outputs_sequence, n=limit)
search_results = []
for item in reranked_results:
search_results.append({"source": item[0], "relationship": item[1], "destination": item[2]})
logger.info(f"Returned {len(search_results)} search results")
return search_results
def delete_all(self, filters):
# Build node properties for filtering
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
if filters.get("run_id"):
node_props.append("run_id: $run_id")
node_props_str = ", ".join(node_props)
cypher = f"""
MATCH (n {self.node_label} {{{node_props_str}}})
DETACH DELETE n
"""
params = {"user_id": filters["user_id"]}
if filters.get("agent_id"):
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
params["run_id"] = filters["run_id"]
self.kuzu_execute(cypher, parameters=params)
def get_all(self, filters, limit=100):
params = {
"user_id": filters["user_id"],
"limit": limit,
}
# Build node properties based on filters
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
node_props.append("run_id: $run_id")
params["run_id"] = filters["run_id"]
node_props_str = ", ".join(node_props)
query = f"""
MATCH (n {self.node_label} {{{node_props_str}}})-[r]->(m {self.node_label} {{{node_props_str}}})
RETURN
n.name AS source,
r.name AS relationship,
m.name AS target
LIMIT $limit
"""
results = self.kuzu_execute(query, parameters=params)
final_results = []
for result in results:
final_results.append(
{
"source": result["source"],
"relationship": result["relationship"],
"target": result["target"],
}
)
logger.info(f"Retrieved {len(final_results)} relationships")
return final_results
def _retrieve_nodes_from_data(self, data, filters):
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
search_results = self.llm.generate_response(
messages=[
{
"role": "system",
"content": f"You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use {filters['user_id']} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question.",
},
{"role": "user", "content": data},
],
tools=_tools,
)
entity_type_map = {}
try:
for tool_call in search_results["tool_calls"]:
if tool_call["name"] != "extract_entities":
continue
for item in tool_call.get("arguments", {}).get("entities", []):
entity_type_map[item["entity"]] = item["entity_type"]
except Exception as e:
logger.exception(
f"Error in search tool: {e}, llm_provider={self.llm_provider}, search_results={search_results}"
)
entity_type_map = {k.lower().replace(" ", "_"): v.lower().replace(" ", "_") for k, v in entity_type_map.items()}
logger.debug(f"Entity type map: {entity_type_map}\n search_results={search_results}")
return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
if filters.get("agent_id"):
user_identity += f", agent_id: {filters['agent_id']}"
if filters.get("run_id"):
user_identity += f", run_id: {filters['run_id']}"
if self.config.graph_store.custom_prompt:
system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
# Add the custom prompt line if configured
system_content = system_content.replace("CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}")
messages = [
{"role": "system", "content": system_content},
{"role": "user", "content": data},
]
else:
system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
messages = [
{"role": "system", "content": system_content},
{"role": "user", "content": f"List of entities: {list(entity_type_map.keys())}. \n\nText: {data}"},
]
_tools = [RELATIONS_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [RELATIONS_STRUCT_TOOL]
extracted_entities = self.llm.generate_response(
messages=messages,
tools=_tools,
)
entities = []
if extracted_entities.get("tool_calls"):
entities = extracted_entities["tool_calls"][0].get("arguments", {}).get("entities", [])
entities = self._remove_spaces_from_entities(entities)
logger.debug(f"Extracted entities: {entities}")
return entities
def _search_graph_db(self, node_list, filters, limit=100, threshold=None):
result_relations = []
params = {
"threshold": threshold if threshold else self.threshold,
"user_id": filters["user_id"],
"limit": limit,
}
# Build node properties for filtering
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
node_props.append("run_id: $run_id")
params["run_id"] = filters["run_id"]
node_props_str = ", ".join(node_props)
for node in node_list:
n_embedding = self.embedding_model.embed(node)
params["n_embedding"] = n_embedding
results = []
for match_fragment in [
f"(n)-[r]->(m {self.node_label} {{{node_props_str}}}) WITH n as src, r, m as dst, similarity",
f"(m {self.node_label} {{{node_props_str}}})-[r]->(n) WITH m as src, r, n as dst, similarity"
]:
results.extend(self.kuzu_execute(
f"""
MATCH (n {self.node_label} {{{node_props_str}}})
WHERE n.embedding IS NOT NULL
WITH n, array_cosine_similarity(n.embedding, CAST($n_embedding,'FLOAT[{self.embedding_dims}]')) AS similarity
WHERE similarity >= CAST($threshold, 'DOUBLE')
MATCH {match_fragment}
RETURN
src.name AS source,
id(src) AS source_id,
r.name AS relationship,
id(r) AS relation_id,
dst.name AS destination,
id(dst) AS destination_id,
similarity
LIMIT $limit
""",
parameters=params))
# Kuzu does not support sort/limit over unions. Do it manually for now.
result_relations.extend(sorted(results, key=lambda x: x["similarity"], reverse=True)[:limit])
return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
search_output_string = format_entities(search_output)
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
if filters.get("agent_id"):
user_identity += f", agent_id: {filters['agent_id']}"
if filters.get("run_id"):
user_identity += f", run_id: {filters['run_id']}"
system_prompt, user_prompt = get_delete_messages(search_output_string, data, user_identity)
_tools = [DELETE_MEMORY_TOOL_GRAPH]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
]
memory_updates = self.llm.generate_response(
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
tools=_tools,
)
to_be_deleted = []
for item in memory_updates.get("tool_calls", []):
if item.get("name") == "delete_graph_memory":
to_be_deleted.append(item.get("arguments"))
# Clean entities formatting
to_be_deleted = self._remove_spaces_from_entities(to_be_deleted)
logger.debug(f"Deleted relationships: {to_be_deleted}")
return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
results = []
for item in to_be_deleted:
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
params = {
"source_name": source,
"dest_name": destination,
"user_id": user_id,
"relationship_name": relationship,
}
# Build node properties for filtering
source_props = ["name: $source_name", "user_id: $user_id"]
dest_props = ["name: $dest_name", "user_id: $user_id"]
if agent_id:
source_props.append("agent_id: $agent_id")
dest_props.append("agent_id: $agent_id")
params["agent_id"] = agent_id
if run_id:
source_props.append("run_id: $run_id")
dest_props.append("run_id: $run_id")
params["run_id"] = run_id
source_props_str = ", ".join(source_props)
dest_props_str = ", ".join(dest_props)
# Delete the specific relationship between nodes
cypher = f"""
MATCH (n {self.node_label} {{{source_props_str}}})
-[r {self.rel_label} {{name: $relationship_name}}]->
(m {self.node_label} {{{dest_props_str}}})
DELETE r
RETURN
n.name AS source,
r.name AS relationship,
m.name AS target
"""
result = self.kuzu_execute(cypher, parameters=params)
results.append(result)
return results
def _add_entities(self, to_be_added, filters, entity_type_map):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
results = []
for item in to_be_added:
# entities
source = item["source"]
source_label = self.node_label
destination = item["destination"]
destination_label = self.node_label
relationship = item["relationship"]
relationship_label = self.rel_label
# embeddings
source_embedding = self.embedding_model.embed(source)
dest_embedding = self.embedding_model.embed(destination)
# search for the nodes with the closest embeddings
source_node_search_result = self._search_source_node(source_embedding, filters, threshold=self.threshold)
destination_node_search_result = self._search_destination_node(dest_embedding, filters, threshold=self.threshold)
if not destination_node_search_result and source_node_search_result:
params = {
"table_id": source_node_search_result[0]["id"]["table"],
"offset_id": source_node_search_result[0]["id"]["offset"],
"destination_name": destination,
"destination_embedding": dest_embedding,
"relationship_name": relationship,
"user_id": user_id,
}
# Build source MERGE properties
merge_props = ["name: $destination_name", "user_id: $user_id"]
if agent_id:
merge_props.append("agent_id: $agent_id")
params["agent_id"] = agent_id
if run_id:
merge_props.append("run_id: $run_id")
params["run_id"] = run_id
merge_props_str = ", ".join(merge_props)
cypher = f"""
MATCH (source)
WHERE id(source) = internal_id($table_id, $offset_id)
SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
MERGE (destination {destination_label} {{{merge_props_str}}})
ON CREATE SET
destination.created = current_timestamp(),
destination.mentions = 1,
destination.embedding = CAST($destination_embedding,'FLOAT[{self.embedding_dims}]')
ON MATCH SET
destination.mentions = coalesce(destination.mentions, 0) + 1,
destination.embedding = CAST($destination_embedding,'FLOAT[{self.embedding_dims}]')
WITH source, destination
MERGE (source)-[r {relationship_label} {{name: $relationship_name}}]->(destination)
ON CREATE SET
r.created = current_timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1
RETURN
source.name AS source,
r.name AS relationship,
destination.name AS target
"""
elif destination_node_search_result and not source_node_search_result:
params = {
"table_id": destination_node_search_result[0]["id"]["table"],
"offset_id": destination_node_search_result[0]["id"]["offset"],
"source_name": source,
"source_embedding": source_embedding,
"user_id": user_id,
"relationship_name": relationship,
}
# Build source MERGE properties
merge_props = ["name: $source_name", "user_id: $user_id"]
if agent_id:
merge_props.append("agent_id: $agent_id")
params["agent_id"] = agent_id
if run_id:
merge_props.append("run_id: $run_id")
params["run_id"] = run_id
merge_props_str = ", ".join(merge_props)
cypher = f"""
MATCH (destination)
WHERE id(destination) = internal_id($table_id, $offset_id)
SET destination.mentions = coalesce(destination.mentions, 0) + 1
WITH destination
MERGE (source {source_label} {{{merge_props_str}}})
ON CREATE SET
source.created = current_timestamp(),
source.mentions = 1,
source.embedding = CAST($source_embedding,'FLOAT[{self.embedding_dims}]')
ON MATCH SET
source.mentions = coalesce(source.mentions, 0) + 1,
source.embedding = CAST($source_embedding,'FLOAT[{self.embedding_dims}]')
WITH source, destination
MERGE (source)-[r {relationship_label} {{name: $relationship_name}}]->(destination)
ON CREATE SET
r.created = current_timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1
RETURN
source.name AS source,
r.name AS relationship,
destination.name AS target
"""
elif source_node_search_result and destination_node_search_result:
cypher = f"""
MATCH (source)
WHERE id(source) = internal_id($src_table, $src_offset)
SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
MATCH (destination)
WHERE id(destination) = internal_id($dst_table, $dst_offset)
SET destination.mentions = coalesce(destination.mentions, 0) + 1
MERGE (source)-[r {relationship_label} {{name: $relationship_name}}]->(destination)
ON CREATE SET
r.created = current_timestamp(),
r.updated = current_timestamp(),
r.mentions = 1
ON MATCH SET r.mentions = coalesce(r.mentions, 0) + 1
RETURN
source.name AS source,
r.name AS relationship,
destination.name AS target
"""
params = {
"src_table": source_node_search_result[0]["id"]["table"],
"src_offset": source_node_search_result[0]["id"]["offset"],
"dst_table": destination_node_search_result[0]["id"]["table"],
"dst_offset": destination_node_search_result[0]["id"]["offset"],
"relationship_name": relationship,
}
else:
params = {
"source_name": source,
"dest_name": destination,
"relationship_name": relationship,
"source_embedding": source_embedding,
"dest_embedding": dest_embedding,
"user_id": user_id,
}
# Build dynamic MERGE props for both source and destination
source_props = ["name: $source_name", "user_id: $user_id"]
dest_props = ["name: $dest_name", "user_id: $user_id"]
if agent_id:
source_props.append("agent_id: $agent_id")
dest_props.append("agent_id: $agent_id")
params["agent_id"] = agent_id
if run_id:
source_props.append("run_id: $run_id")
dest_props.append("run_id: $run_id")
params["run_id"] = run_id
source_props_str = ", ".join(source_props)
dest_props_str = ", ".join(dest_props)
cypher = f"""
MERGE (source {source_label} {{{source_props_str}}})
ON CREATE SET
source.created = current_timestamp(),
source.mentions = 1,
source.embedding = CAST($source_embedding,'FLOAT[{self.embedding_dims}]')
ON MATCH SET
source.mentions = coalesce(source.mentions, 0) + 1,
source.embedding = CAST($source_embedding,'FLOAT[{self.embedding_dims}]')
WITH source
MERGE (destination {destination_label} {{{dest_props_str}}})
ON CREATE SET
destination.created = current_timestamp(),
destination.mentions = 1,
destination.embedding = CAST($dest_embedding,'FLOAT[{self.embedding_dims}]')
ON MATCH SET
destination.mentions = coalesce(destination.mentions, 0) + 1,
destination.embedding = CAST($dest_embedding,'FLOAT[{self.embedding_dims}]')
WITH source, destination
MERGE (source)-[rel {relationship_label} {{name: $relationship_name}}]->(destination)
ON CREATE SET
rel.created = current_timestamp(),
rel.mentions = 1
ON MATCH SET
rel.mentions = coalesce(rel.mentions, 0) + 1
RETURN
source.name AS source,
rel.name AS relationship,
destination.name AS target
"""
result = self.kuzu_execute(cypher, parameters=params)
results.append(result)
return results
def _remove_spaces_from_entities(self, entity_list):
for item in entity_list:
item["source"] = item["source"].lower().replace(" ", "_")
item["relationship"] = item["relationship"].lower().replace(" ", "_")
item["destination"] = item["destination"].lower().replace(" ", "_")
return entity_list
def _search_source_node(self, source_embedding, filters, threshold=0.9):
params = {
"source_embedding": source_embedding,
"user_id": filters["user_id"],
"threshold": threshold,
}
where_conditions = ["source_candidate.embedding IS NOT NULL", "source_candidate.user_id = $user_id"]
if filters.get("agent_id"):
where_conditions.append("source_candidate.agent_id = $agent_id")
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
where_conditions.append("source_candidate.run_id = $run_id")
params["run_id"] = filters["run_id"]
where_clause = " AND ".join(where_conditions)
cypher = f"""
MATCH (source_candidate {self.node_label})
WHERE {where_clause}
WITH source_candidate,
array_cosine_similarity(source_candidate.embedding, CAST($source_embedding,'FLOAT[{self.embedding_dims}]')) AS source_similarity
WHERE source_similarity >= $threshold
WITH source_candidate, source_similarity
ORDER BY source_similarity DESC
LIMIT 2
RETURN id(source_candidate) as id, source_similarity
"""
return self.kuzu_execute(cypher, parameters=params)
def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
params = {
"destination_embedding": destination_embedding,
"user_id": filters["user_id"],
"threshold": threshold,
}
where_conditions = ["destination_candidate.embedding IS NOT NULL", "destination_candidate.user_id = $user_id"]
if filters.get("agent_id"):
where_conditions.append("destination_candidate.agent_id = $agent_id")
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
where_conditions.append("destination_candidate.run_id = $run_id")
params["run_id"] = filters["run_id"]
where_clause = " AND ".join(where_conditions)
cypher = f"""
MATCH (destination_candidate {self.node_label})
WHERE {where_clause}
WITH destination_candidate,
array_cosine_similarity(destination_candidate.embedding, CAST($destination_embedding,'FLOAT[{self.embedding_dims}]')) AS destination_similarity
WHERE destination_similarity >= $threshold
WITH destination_candidate, destination_similarity
ORDER BY destination_similarity DESC
LIMIT 2
RETURN id(destination_candidate) as id, destination_similarity
"""
return self.kuzu_execute(cypher, parameters=params)
# Reset is not defined in base.py
def reset(self):
logger.warning("Clearing graph...")
cypher_query = """
MATCH (n) DETACH DELETE n
"""
return self.kuzu_execute(cypher_query) | --- +++ @@ -96,6 +96,13 @@ return list(results.rows_as_dict())
def add(self, data, filters):
+ """
+ Adds data to the graph.
+
+ Args:
+ data (str): The data to add to the graph.
+ filters (dict): A dictionary containing filters to be applied during the addition.
+ """
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -107,6 +114,19 @@ return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=5):
+ """
+ Search for memories and related graph data.
+
+ Args:
+ query (str): Query to search for.
+ filters (dict): A dictionary containing filters to be applied during the search.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing:
+ - "contexts": List of search results from the base data store.
+ - "entities": List of related graph data based on the query.
+ """
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -150,6 +170,16 @@ self.kuzu_execute(cypher, parameters=params)
def get_all(self, filters, limit=100):
+ """
+ Retrieves all nodes and relationships from the graph database based on optional filtering criteria.
+ Args:
+ filters (dict): A dictionary containing filters to be applied during the retrieval.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+ Returns:
+ list: A list of dictionaries, each containing:
+ - 'contexts': The base data store response for each memory.
+ - 'entities': A list of strings representing the nodes and relationships
+ """
params = {
"user_id": filters["user_id"],
@@ -190,6 +220,7 @@ return final_results
def _retrieve_nodes_from_data(self, data, filters):
+ """Extracts all the entities mentioned in the query."""
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
@@ -222,6 +253,7 @@ return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
+ """Establish relations among the extracted nodes."""
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
@@ -263,6 +295,7 @@ return entities
def _search_graph_db(self, node_list, filters, limit=100, threshold=None):
+ """Search similar nodes among and their respective incoming and outgoing relations."""
result_relations = []
params = {
@@ -314,6 +347,7 @@ return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
+ """Get the entities to be deleted from the search output."""
search_output_string = format_entities(search_output)
# Compose user identification string for prompt
@@ -349,6 +383,7 @@ return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
+ """Delete the entities from the graph."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
@@ -397,6 +432,7 @@ return results
def _add_entities(self, to_be_added, filters, entity_type_map):
+ """Add the new entities to the graph. Merge the nodes if they already exist."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
@@ -670,8 +706,9 @@
# Reset is not defined in base.py
def reset(self):
+ """Reset the graph by clearing all nodes and relationships."""
logger.warning("Clearing graph...")
cypher_query = """
MATCH (n) DETACH DELETE n
"""
- return self.kuzu_execute(cypher_query)+ return self.kuzu_execute(cypher_query)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/memory/kuzu_memory.py |
Document all public functions with docstrings | import json
import os
from typing import Dict, List, Optional, Union
from openai import OpenAI
from mem0.configs.llms.base import BaseLlmConfig
from mem0.configs.llms.deepseek import DeepSeekConfig
from mem0.llms.base import LLMBase
from mem0.memory.utils import extract_json
class DeepSeekLLM(LLMBase):
def __init__(self, config: Optional[Union[BaseLlmConfig, DeepSeekConfig, Dict]] = None):
# Convert to DeepSeekConfig if needed
if config is None:
config = DeepSeekConfig()
elif isinstance(config, dict):
config = DeepSeekConfig(**config)
elif isinstance(config, BaseLlmConfig) and not isinstance(config, DeepSeekConfig):
# Convert BaseLlmConfig to DeepSeekConfig
config = DeepSeekConfig(
model=config.model,
temperature=config.temperature,
api_key=config.api_key,
max_tokens=config.max_tokens,
top_p=config.top_p,
top_k=config.top_k,
enable_vision=config.enable_vision,
vision_details=config.vision_details,
http_client_proxies=config.http_client,
)
super().__init__(config)
if not self.config.model:
self.config.model = "deepseek-chat"
api_key = self.config.api_key or os.getenv("DEEPSEEK_API_KEY")
base_url = self.config.deepseek_base_url or os.getenv("DEEPSEEK_API_BASE") or "https://api.deepseek.com"
self.client = OpenAI(api_key=api_key, base_url=base_url)
def _parse_response(self, response, tools):
if tools:
processed_response = {
"content": response.choices[0].message.content,
"tool_calls": [],
}
if response.choices[0].message.tool_calls:
for tool_call in response.choices[0].message.tool_calls:
processed_response["tool_calls"].append(
{
"name": tool_call.function.name,
"arguments": json.loads(extract_json(tool_call.function.arguments)),
}
)
return processed_response
else:
return response.choices[0].message.content
def generate_response(
self,
messages: List[Dict[str, str]],
response_format=None,
tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
**kwargs,
):
params = self._get_supported_params(messages=messages, **kwargs)
params.update(
{
"model": self.config.model,
"messages": messages,
}
)
if tools:
params["tools"] = tools
params["tool_choice"] = tool_choice
response = self.client.chat.completions.create(**params)
return self._parse_response(response, tools) | --- +++ @@ -41,6 +41,16 @@ self.client = OpenAI(api_key=api_key, base_url=base_url)
def _parse_response(self, response, tools):
+ """
+ Process the response based on whether tools are used or not.
+
+ Args:
+ response: The raw response from API.
+ tools: The list of tools provided in the request.
+
+ Returns:
+ str or dict: The processed response.
+ """
if tools:
processed_response = {
"content": response.choices[0].message.content,
@@ -68,6 +78,19 @@ tool_choice: str = "auto",
**kwargs,
):
+ """
+ Generate a response based on the given messages using DeepSeek.
+
+ Args:
+ messages (list): List of message dicts containing 'role' and 'content'.
+ response_format (str or object, optional): Format of the response. Defaults to "text".
+ tools (list, optional): List of tools that the model can call. Defaults to None.
+ tool_choice (str, optional): Tool choice method. Defaults to "auto".
+ **kwargs: Additional DeepSeek-specific parameters.
+
+ Returns:
+ str: The generated response.
+ """
params = self._get_supported_params(messages=messages, **kwargs)
params.update(
{
@@ -81,4 +104,4 @@ params["tool_choice"] = tool_choice
response = self.client.chat.completions.create(**params)
- return self._parse_response(response, tools)+ return self._parse_response(response, tools)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/llms/deepseek.py |
Generate missing documentation strings | import asyncio
import concurrent
import gc
import hashlib
import json
import logging
import os
import uuid
import warnings
from copy import deepcopy
from datetime import datetime
from typing import Any, Dict, Optional
import pytz
from pydantic import ValidationError
from mem0.configs.base import MemoryConfig, MemoryItem
from mem0.configs.enums import MemoryType
from mem0.configs.prompts import (
PROCEDURAL_MEMORY_SYSTEM_PROMPT,
get_update_memory_messages,
)
from mem0.exceptions import ValidationError as Mem0ValidationError
from mem0.memory.base import MemoryBase
from mem0.memory.setup import mem0_dir, setup_config
from mem0.memory.storage import SQLiteManager
from mem0.memory.telemetry import MEM0_TELEMETRY, capture_event
from mem0.memory.utils import (
ensure_json_instruction,
extract_json,
get_fact_retrieval_messages,
normalize_facts,
parse_messages,
parse_vision_messages,
process_telemetry_filters,
remove_code_blocks,
)
from mem0.utils.factory import (
EmbedderFactory,
GraphStoreFactory,
LlmFactory,
RerankerFactory,
VectorStoreFactory,
)
# Suppress SWIG deprecation warnings globally
warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*SwigPy.*")
warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*swigvarlink.*")
# Initialize logger early for util functions
logger = logging.getLogger(__name__)
def _safe_deepcopy_config(config):
try:
return deepcopy(config)
except Exception as e:
logger.debug(f"Deepcopy failed, using JSON serialization: {e}")
config_class = type(config)
if hasattr(config, "model_dump"):
try:
clone_dict = config.model_dump(mode="json")
except Exception:
clone_dict = {k: v for k, v in config.__dict__.items()}
elif hasattr(config, "__dataclass_fields__"):
from dataclasses import asdict
clone_dict = asdict(config)
else:
clone_dict = {k: v for k, v in config.__dict__.items()}
sensitive_tokens = ("auth", "credential", "password", "token", "secret", "key", "connection_class")
for field_name in list(clone_dict.keys()):
if any(token in field_name.lower() for token in sensitive_tokens):
clone_dict[field_name] = None
try:
return config_class(**clone_dict)
except Exception as reconstruction_error:
logger.warning(
f"Failed to reconstruct config: {reconstruction_error}. "
f"Telemetry may be affected."
)
raise
def _build_filters_and_metadata(
*, # Enforce keyword-only arguments
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
actor_id: Optional[str] = None, # For query-time filtering
input_metadata: Optional[Dict[str, Any]] = None,
input_filters: Optional[Dict[str, Any]] = None,
) -> tuple[Dict[str, Any], Dict[str, Any]]:
base_metadata_template = deepcopy(input_metadata) if input_metadata else {}
effective_query_filters = deepcopy(input_filters) if input_filters else {}
# ---------- add all provided session ids ----------
session_ids_provided = []
if user_id:
base_metadata_template["user_id"] = user_id
effective_query_filters["user_id"] = user_id
session_ids_provided.append("user_id")
if agent_id:
base_metadata_template["agent_id"] = agent_id
effective_query_filters["agent_id"] = agent_id
session_ids_provided.append("agent_id")
if run_id:
base_metadata_template["run_id"] = run_id
effective_query_filters["run_id"] = run_id
session_ids_provided.append("run_id")
if not session_ids_provided:
raise Mem0ValidationError(
message="At least one of 'user_id', 'agent_id', or 'run_id' must be provided.",
error_code="VALIDATION_001",
details={"provided_ids": {"user_id": user_id, "agent_id": agent_id, "run_id": run_id}},
suggestion="Please provide at least one identifier to scope the memory operation."
)
# ---------- optional actor filter ----------
resolved_actor_id = actor_id or effective_query_filters.get("actor_id")
if resolved_actor_id:
effective_query_filters["actor_id"] = resolved_actor_id
return base_metadata_template, effective_query_filters
setup_config()
logger = logging.getLogger(__name__)
class Memory(MemoryBase):
def __init__(self, config: MemoryConfig = MemoryConfig()):
self.config = config
self.custom_fact_extraction_prompt = self.config.custom_fact_extraction_prompt
self.custom_update_memory_prompt = self.config.custom_update_memory_prompt
self.embedding_model = EmbedderFactory.create(
self.config.embedder.provider,
self.config.embedder.config,
self.config.vector_store.config,
)
self.vector_store = VectorStoreFactory.create(
self.config.vector_store.provider, self.config.vector_store.config
)
self.llm = LlmFactory.create(self.config.llm.provider, self.config.llm.config)
self.db = SQLiteManager(self.config.history_db_path)
self.collection_name = self.config.vector_store.config.collection_name
self.api_version = self.config.version
# Initialize reranker if configured
self.reranker = None
if config.reranker:
self.reranker = RerankerFactory.create(
config.reranker.provider,
config.reranker.config
)
self.enable_graph = False
if self.config.graph_store.config:
provider = self.config.graph_store.provider
self.graph = GraphStoreFactory.create(provider, self.config)
self.enable_graph = True
else:
self.graph = None
if MEM0_TELEMETRY:
# Create telemetry config manually to avoid deepcopy issues with thread locks
telemetry_config_dict = {}
if hasattr(self.config.vector_store.config, 'model_dump'):
# For pydantic models
telemetry_config_dict = self.config.vector_store.config.model_dump()
else:
# For other objects, manually copy common attributes
for attr in ['host', 'port', 'path', 'api_key', 'index_name', 'dimension', 'metric']:
if hasattr(self.config.vector_store.config, attr):
telemetry_config_dict[attr] = getattr(self.config.vector_store.config, attr)
# Override collection name for telemetry
telemetry_config_dict['collection_name'] = "mem0migrations"
# Set path for file-based vector stores
telemetry_config = _safe_deepcopy_config(self.config.vector_store.config)
if self.config.vector_store.provider in ["faiss", "qdrant"]:
provider_path = f"migrations_{self.config.vector_store.provider}"
telemetry_config_dict['path'] = os.path.join(mem0_dir, provider_path)
os.makedirs(telemetry_config_dict['path'], exist_ok=True)
# Create the config object using the same class as the original
telemetry_config = self.config.vector_store.config.__class__(**telemetry_config_dict)
self._telemetry_vector_store = VectorStoreFactory.create(
self.config.vector_store.provider, telemetry_config
)
capture_event("mem0.init", self, {"sync_type": "sync"})
@classmethod
def from_config(cls, config_dict: Dict[str, Any]):
try:
config = cls._process_config(config_dict)
config = MemoryConfig(**config_dict)
except ValidationError as e:
logger.error(f"Configuration validation error: {e}")
raise
return cls(config)
@staticmethod
def _process_config(config_dict: Dict[str, Any]) -> Dict[str, Any]:
if "graph_store" in config_dict:
if "vector_store" not in config_dict and "embedder" in config_dict:
config_dict["vector_store"] = {}
config_dict["vector_store"]["config"] = {}
config_dict["vector_store"]["config"]["embedding_model_dims"] = config_dict["embedder"]["config"][
"embedding_dims"
]
try:
return config_dict
except ValidationError as e:
logger.error(f"Configuration validation error: {e}")
raise
def _should_use_agent_memory_extraction(self, messages, metadata):
# Check if agent_id is present in metadata
has_agent_id = metadata.get("agent_id") is not None
# Check if there are assistant role messages
has_assistant_messages = any(msg.get("role") == "assistant" for msg in messages)
# Use agent memory extraction if agent_id is present and there are assistant messages
return has_agent_id and has_assistant_messages
def add(
self,
messages,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
metadata: Optional[Dict[str, Any]] = None,
infer: bool = True,
memory_type: Optional[str] = None,
prompt: Optional[str] = None,
):
processed_metadata, effective_filters = _build_filters_and_metadata(
user_id=user_id,
agent_id=agent_id,
run_id=run_id,
input_metadata=metadata,
)
if memory_type is not None and memory_type != MemoryType.PROCEDURAL.value:
raise Mem0ValidationError(
message=f"Invalid 'memory_type'. Please pass {MemoryType.PROCEDURAL.value} to create procedural memories.",
error_code="VALIDATION_002",
details={"provided_type": memory_type, "valid_type": MemoryType.PROCEDURAL.value},
suggestion=f"Use '{MemoryType.PROCEDURAL.value}' to create procedural memories."
)
if isinstance(messages, str):
messages = [{"role": "user", "content": messages}]
elif isinstance(messages, dict):
messages = [messages]
elif not isinstance(messages, list):
raise Mem0ValidationError(
message="messages must be str, dict, or list[dict]",
error_code="VALIDATION_003",
details={"provided_type": type(messages).__name__, "valid_types": ["str", "dict", "list[dict]"]},
suggestion="Convert your input to a string, dictionary, or list of dictionaries."
)
if agent_id is not None and memory_type == MemoryType.PROCEDURAL.value:
results = self._create_procedural_memory(messages, metadata=processed_metadata, prompt=prompt)
return results
if self.config.llm.config.get("enable_vision"):
messages = parse_vision_messages(messages, self.llm, self.config.llm.config.get("vision_details"))
else:
messages = parse_vision_messages(messages)
with concurrent.futures.ThreadPoolExecutor() as executor:
future1 = executor.submit(self._add_to_vector_store, messages, processed_metadata, effective_filters, infer)
future2 = executor.submit(self._add_to_graph, messages, effective_filters)
concurrent.futures.wait([future1, future2])
vector_store_result = future1.result()
graph_result = future2.result()
if self.enable_graph:
return {
"results": vector_store_result,
"relations": graph_result,
}
return {"results": vector_store_result}
def _add_to_vector_store(self, messages, metadata, filters, infer):
if not infer:
returned_memories = []
for message_dict in messages:
if (
not isinstance(message_dict, dict)
or message_dict.get("role") is None
or message_dict.get("content") is None
):
logger.warning(f"Skipping invalid message format: {message_dict}")
continue
if message_dict["role"] == "system":
continue
per_msg_meta = deepcopy(metadata)
per_msg_meta["role"] = message_dict["role"]
actor_name = message_dict.get("name")
if actor_name:
per_msg_meta["actor_id"] = actor_name
msg_content = message_dict["content"]
msg_embeddings = self.embedding_model.embed(msg_content, "add")
mem_id = self._create_memory(msg_content, msg_embeddings, per_msg_meta)
returned_memories.append(
{
"id": mem_id,
"memory": msg_content,
"event": "ADD",
"actor_id": actor_name if actor_name else None,
"role": message_dict["role"],
}
)
return returned_memories
parsed_messages = parse_messages(messages)
if self.config.custom_fact_extraction_prompt:
system_prompt = self.config.custom_fact_extraction_prompt
user_prompt = f"Input:\n{parsed_messages}"
else:
# Determine if this should use agent memory extraction based on agent_id presence
# and role types in messages
is_agent_memory = self._should_use_agent_memory_extraction(messages, metadata)
system_prompt, user_prompt = get_fact_retrieval_messages(parsed_messages, is_agent_memory)
# Ensure 'json' appears in prompts for json_object response format compatibility
system_prompt, user_prompt = ensure_json_instruction(system_prompt, user_prompt)
response = self.llm.generate_response(
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
response_format={"type": "json_object"},
)
try:
response = remove_code_blocks(response)
if not response.strip():
new_retrieved_facts = []
else:
try:
# First try direct JSON parsing
new_retrieved_facts = json.loads(response)["facts"]
except json.JSONDecodeError:
# Try extracting JSON from response using built-in function
extracted_json = extract_json(response)
new_retrieved_facts = json.loads(extracted_json)["facts"]
new_retrieved_facts = normalize_facts(new_retrieved_facts)
except Exception as e:
logger.error(f"Error in new_retrieved_facts: {e}")
new_retrieved_facts = []
if not new_retrieved_facts:
logger.debug("No new facts retrieved from input. Skipping memory update LLM call.")
retrieved_old_memory = []
new_message_embeddings = {}
# Search for existing memories using the provided session identifiers
# Use all available session identifiers for accurate memory retrieval
search_filters = {}
if filters.get("user_id"):
search_filters["user_id"] = filters["user_id"]
if filters.get("agent_id"):
search_filters["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
search_filters["run_id"] = filters["run_id"]
for new_mem in new_retrieved_facts:
messages_embeddings = self.embedding_model.embed(new_mem, "add")
new_message_embeddings[new_mem] = messages_embeddings
existing_memories = self.vector_store.search(
query=new_mem,
vectors=messages_embeddings,
limit=5,
filters=search_filters,
)
for mem in existing_memories:
retrieved_old_memory.append({"id": mem.id, "text": mem.payload.get("data", "")})
unique_data = {}
for item in retrieved_old_memory:
unique_data[item["id"]] = item
retrieved_old_memory = list(unique_data.values())
logger.info(f"Total existing memories: {len(retrieved_old_memory)}")
# mapping UUIDs with integers for handling UUID hallucinations
temp_uuid_mapping = {}
for idx, item in enumerate(retrieved_old_memory):
temp_uuid_mapping[str(idx)] = item["id"]
retrieved_old_memory[idx]["id"] = str(idx)
if new_retrieved_facts:
function_calling_prompt = get_update_memory_messages(
retrieved_old_memory, new_retrieved_facts, self.config.custom_update_memory_prompt
)
try:
response: str = self.llm.generate_response(
messages=[{"role": "user", "content": function_calling_prompt}],
response_format={"type": "json_object"},
)
except Exception as e:
logger.error(f"Error in new memory actions response: {e}")
response = ""
try:
if not response or not response.strip():
logger.warning("Empty response from LLM, no memories to extract")
new_memories_with_actions = {}
else:
response = remove_code_blocks(response)
new_memories_with_actions = json.loads(response)
except Exception as e:
logger.error(f"Invalid JSON response: {e}")
new_memories_with_actions = {}
else:
new_memories_with_actions = {}
returned_memories = []
try:
for resp in new_memories_with_actions.get("memory", []):
logger.info(resp)
try:
action_text = resp.get("text")
if not action_text:
logger.info("Skipping memory entry because of empty `text` field.")
continue
event_type = resp.get("event")
if event_type == "ADD":
memory_id = self._create_memory(
data=action_text,
existing_embeddings=new_message_embeddings,
metadata=deepcopy(metadata),
)
returned_memories.append({"id": memory_id, "memory": action_text, "event": event_type})
elif event_type == "UPDATE":
self._update_memory(
memory_id=temp_uuid_mapping[resp.get("id")],
data=action_text,
existing_embeddings=new_message_embeddings,
metadata=deepcopy(metadata),
)
returned_memories.append(
{
"id": temp_uuid_mapping[resp.get("id")],
"memory": action_text,
"event": event_type,
"previous_memory": resp.get("old_memory"),
}
)
elif event_type == "DELETE":
self._delete_memory(memory_id=temp_uuid_mapping[resp.get("id")])
returned_memories.append(
{
"id": temp_uuid_mapping[resp.get("id")],
"memory": action_text,
"event": event_type,
}
)
elif event_type == "NONE":
# Even if content doesn't need updating, update session IDs if provided
memory_id = temp_uuid_mapping.get(resp.get("id"))
if memory_id and (metadata.get("agent_id") or metadata.get("run_id")):
# Update only the session identifiers, keep content the same
existing_memory = self.vector_store.get(vector_id=memory_id)
updated_metadata = deepcopy(existing_memory.payload)
if metadata.get("agent_id"):
updated_metadata["agent_id"] = metadata["agent_id"]
if metadata.get("run_id"):
updated_metadata["run_id"] = metadata["run_id"]
updated_metadata["updated_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
self.vector_store.update(
vector_id=memory_id,
vector=None, # Keep same embeddings
payload=updated_metadata,
)
logger.info(f"Updated session IDs for memory {memory_id}")
else:
logger.info("NOOP for Memory.")
except Exception as e:
logger.error(f"Error processing memory action: {resp}, Error: {e}")
except Exception as e:
logger.error(f"Error iterating new_memories_with_actions: {e}")
keys, encoded_ids = process_telemetry_filters(filters)
capture_event(
"mem0.add",
self,
{"version": self.api_version, "keys": keys, "encoded_ids": encoded_ids, "sync_type": "sync"},
)
return returned_memories
def _add_to_graph(self, messages, filters):
added_entities = []
if self.enable_graph:
if filters.get("user_id") is None:
filters["user_id"] = "user"
data = "\n".join([msg["content"] for msg in messages if "content" in msg and msg["role"] != "system"])
added_entities = self.graph.add(data, filters)
return added_entities
def get(self, memory_id):
capture_event("mem0.get", self, {"memory_id": memory_id, "sync_type": "sync"})
memory = self.vector_store.get(vector_id=memory_id)
if not memory:
return None
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
result_item = MemoryItem(
id=memory.id,
memory=memory.payload.get("data", ""),
hash=memory.payload.get("hash"),
created_at=memory.payload.get("created_at"),
updated_at=memory.payload.get("updated_at"),
).model_dump()
for key in promoted_payload_keys:
if key in memory.payload:
result_item[key] = memory.payload[key]
additional_metadata = {k: v for k, v in memory.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
result_item["metadata"] = additional_metadata
return result_item
def get_all(
self,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
filters: Optional[Dict[str, Any]] = None,
limit: int = 100,
):
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
)
if not any(key in effective_filters for key in ("user_id", "agent_id", "run_id")):
raise ValueError("At least one of 'user_id', 'agent_id', or 'run_id' must be specified.")
keys, encoded_ids = process_telemetry_filters(effective_filters)
capture_event(
"mem0.get_all", self, {"limit": limit, "keys": keys, "encoded_ids": encoded_ids, "sync_type": "sync"}
)
with concurrent.futures.ThreadPoolExecutor() as executor:
future_memories = executor.submit(self._get_all_from_vector_store, effective_filters, limit)
future_graph_entities = (
executor.submit(self.graph.get_all, effective_filters, limit) if self.enable_graph else None
)
concurrent.futures.wait(
[future_memories, future_graph_entities] if future_graph_entities else [future_memories]
)
all_memories_result = future_memories.result()
graph_entities_result = future_graph_entities.result() if future_graph_entities else None
if self.enable_graph:
return {"results": all_memories_result, "relations": graph_entities_result}
return {"results": all_memories_result}
def _get_all_from_vector_store(self, filters, limit):
memories_result = self.vector_store.list(filters=filters, limit=limit)
# Handle different vector store return formats by inspecting first element
if isinstance(memories_result, (tuple, list)) and len(memories_result) > 0:
first_element = memories_result[0]
# If first element is a container, unwrap one level
if isinstance(first_element, (list, tuple)):
actual_memories = first_element
else:
# First element is a memory object, structure is already flat
actual_memories = memories_result
else:
actual_memories = memories_result
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
formatted_memories = []
for mem in actual_memories:
memory_item_dict = MemoryItem(
id=mem.id,
memory=mem.payload.get("data", ""),
hash=mem.payload.get("hash"),
created_at=mem.payload.get("created_at"),
updated_at=mem.payload.get("updated_at"),
).model_dump(exclude={"score"})
for key in promoted_payload_keys:
if key in mem.payload:
memory_item_dict[key] = mem.payload[key]
additional_metadata = {k: v for k, v in mem.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
memory_item_dict["metadata"] = additional_metadata
formatted_memories.append(memory_item_dict)
return formatted_memories
def search(
self,
query: str,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
limit: int = 100,
filters: Optional[Dict[str, Any]] = None,
threshold: Optional[float] = None,
rerank: bool = True,
):
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
)
if not any(key in effective_filters for key in ("user_id", "agent_id", "run_id")):
raise ValueError("At least one of 'user_id', 'agent_id', or 'run_id' must be specified.")
# Apply enhanced metadata filtering if advanced operators are detected
if filters and self._has_advanced_operators(filters):
processed_filters = self._process_metadata_filters(filters)
effective_filters.update(processed_filters)
elif filters:
# Simple filters, merge directly
effective_filters.update(filters)
keys, encoded_ids = process_telemetry_filters(effective_filters)
capture_event(
"mem0.search",
self,
{
"limit": limit,
"version": self.api_version,
"keys": keys,
"encoded_ids": encoded_ids,
"sync_type": "sync",
"threshold": threshold,
"advanced_filters": bool(filters and self._has_advanced_operators(filters)),
},
)
with concurrent.futures.ThreadPoolExecutor() as executor:
future_memories = executor.submit(self._search_vector_store, query, effective_filters, limit, threshold)
future_graph_entities = (
executor.submit(self.graph.search, query, effective_filters, limit) if self.enable_graph else None
)
concurrent.futures.wait(
[future_memories, future_graph_entities] if future_graph_entities else [future_memories]
)
original_memories = future_memories.result()
graph_entities = future_graph_entities.result() if future_graph_entities else None
# Apply reranking if enabled and reranker is available
if rerank and self.reranker and original_memories:
try:
reranked_memories = self.reranker.rerank(query, original_memories, limit)
original_memories = reranked_memories
except Exception as e:
logger.warning(f"Reranking failed, using original results: {e}")
if self.enable_graph:
return {"results": original_memories, "relations": graph_entities}
return {"results": original_memories}
def _process_metadata_filters(self, metadata_filters: Dict[str, Any]) -> Dict[str, Any]:
processed_filters = {}
def process_condition(key: str, condition: Any) -> Dict[str, Any]:
if not isinstance(condition, dict):
# Simple equality: {"key": "value"}
if condition == "*":
# Wildcard: match everything for this field (implementation depends on vector store)
return {key: "*"}
return {key: condition}
result = {}
for operator, value in condition.items():
# Map platform operators to universal format that can be translated by each vector store
operator_map = {
"eq": "eq", "ne": "ne", "gt": "gt", "gte": "gte",
"lt": "lt", "lte": "lte", "in": "in", "nin": "nin",
"contains": "contains", "icontains": "icontains"
}
if operator in operator_map:
result[key] = {operator_map[operator]: value}
else:
raise ValueError(f"Unsupported metadata filter operator: {operator}")
return result
for key, value in metadata_filters.items():
if key == "AND":
# Logical AND: combine multiple conditions
if not isinstance(value, list):
raise ValueError("AND operator requires a list of conditions")
for condition in value:
for sub_key, sub_value in condition.items():
processed_filters.update(process_condition(sub_key, sub_value))
elif key == "OR":
# Logical OR: Pass through to vector store for implementation-specific handling
if not isinstance(value, list) or not value:
raise ValueError("OR operator requires a non-empty list of conditions")
# Store OR conditions in a way that vector stores can interpret
processed_filters["$or"] = []
for condition in value:
or_condition = {}
for sub_key, sub_value in condition.items():
or_condition.update(process_condition(sub_key, sub_value))
processed_filters["$or"].append(or_condition)
elif key == "NOT":
# Logical NOT: Pass through to vector store for implementation-specific handling
if not isinstance(value, list) or not value:
raise ValueError("NOT operator requires a non-empty list of conditions")
processed_filters["$not"] = []
for condition in value:
not_condition = {}
for sub_key, sub_value in condition.items():
not_condition.update(process_condition(sub_key, sub_value))
processed_filters["$not"].append(not_condition)
else:
processed_filters.update(process_condition(key, value))
return processed_filters
def _has_advanced_operators(self, filters: Dict[str, Any]) -> bool:
if not isinstance(filters, dict):
return False
for key, value in filters.items():
# Check for platform-style logical operators
if key in ["AND", "OR", "NOT"]:
return True
# Check for comparison operators (without $ prefix for universal compatibility)
if isinstance(value, dict):
for op in value.keys():
if op in ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "icontains"]:
return True
# Check for wildcard values
if value == "*":
return True
return False
def _search_vector_store(self, query, filters, limit, threshold: Optional[float] = None):
embeddings = self.embedding_model.embed(query, "search")
memories = self.vector_store.search(query=query, vectors=embeddings, limit=limit, filters=filters)
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
original_memories = []
for mem in memories:
memory_item_dict = MemoryItem(
id=mem.id,
memory=mem.payload.get("data", ""),
hash=mem.payload.get("hash"),
created_at=mem.payload.get("created_at"),
updated_at=mem.payload.get("updated_at"),
score=mem.score,
).model_dump()
for key in promoted_payload_keys:
if key in mem.payload:
memory_item_dict[key] = mem.payload[key]
additional_metadata = {k: v for k, v in mem.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
memory_item_dict["metadata"] = additional_metadata
if threshold is None or mem.score >= threshold:
original_memories.append(memory_item_dict)
return original_memories
def update(self, memory_id, data):
capture_event("mem0.update", self, {"memory_id": memory_id, "sync_type": "sync"})
existing_embeddings = {data: self.embedding_model.embed(data, "update")}
self._update_memory(memory_id, data, existing_embeddings)
return {"message": "Memory updated successfully!"}
def delete(self, memory_id):
capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "sync"})
self._delete_memory(memory_id)
return {"message": "Memory deleted successfully!"}
def delete_all(self, user_id: Optional[str] = None, agent_id: Optional[str] = None, run_id: Optional[str] = None):
filters: Dict[str, Any] = {}
if user_id:
filters["user_id"] = user_id
if agent_id:
filters["agent_id"] = agent_id
if run_id:
filters["run_id"] = run_id
if not filters:
raise ValueError(
"At least one filter is required to delete all memories. If you want to delete all memories, use the `reset()` method."
)
keys, encoded_ids = process_telemetry_filters(filters)
capture_event("mem0.delete_all", self, {"keys": keys, "encoded_ids": encoded_ids, "sync_type": "sync"})
# delete matching vector memories individually (do NOT reset the collection)
memories = self.vector_store.list(filters=filters)[0]
for memory in memories:
self._delete_memory(memory.id)
logger.info(f"Deleted {len(memories)} memories")
if self.enable_graph:
self.graph.delete_all(filters)
return {"message": "Memories deleted successfully!"}
def history(self, memory_id):
capture_event("mem0.history", self, {"memory_id": memory_id, "sync_type": "sync"})
return self.db.get_history(memory_id)
def _create_memory(self, data, existing_embeddings, metadata=None):
logger.debug(f"Creating memory with {data=}")
if data in existing_embeddings:
embeddings = existing_embeddings[data]
else:
embeddings = self.embedding_model.embed(data, memory_action="add")
memory_id = str(uuid.uuid4())
metadata = metadata or {}
metadata["data"] = data
metadata["hash"] = hashlib.md5(data.encode()).hexdigest()
metadata["created_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
self.vector_store.insert(
vectors=[embeddings],
ids=[memory_id],
payloads=[metadata],
)
self.db.add_history(
memory_id,
None,
data,
"ADD",
created_at=metadata.get("created_at"),
actor_id=metadata.get("actor_id"),
role=metadata.get("role"),
)
return memory_id
def _create_procedural_memory(self, messages, metadata=None, prompt=None):
logger.info("Creating procedural memory")
parsed_messages = [
{"role": "system", "content": prompt or PROCEDURAL_MEMORY_SYSTEM_PROMPT},
*messages,
{
"role": "user",
"content": "Create procedural memory of the above conversation.",
},
]
try:
procedural_memory = self.llm.generate_response(messages=parsed_messages)
procedural_memory = remove_code_blocks(procedural_memory)
except Exception as e:
logger.error(f"Error generating procedural memory summary: {e}")
raise
if metadata is None:
raise ValueError("Metadata cannot be done for procedural memory.")
metadata["memory_type"] = MemoryType.PROCEDURAL.value
embeddings = self.embedding_model.embed(procedural_memory, memory_action="add")
memory_id = self._create_memory(procedural_memory, {procedural_memory: embeddings}, metadata=metadata)
capture_event("mem0._create_procedural_memory", self, {"memory_id": memory_id, "sync_type": "sync"})
result = {"results": [{"id": memory_id, "memory": procedural_memory, "event": "ADD"}]}
return result
def _update_memory(self, memory_id, data, existing_embeddings, metadata=None):
logger.info(f"Updating memory with {data=}")
try:
existing_memory = self.vector_store.get(vector_id=memory_id)
except Exception:
logger.error(f"Error getting memory with ID {memory_id} during update.")
raise ValueError(f"Error getting memory with ID {memory_id}. Please provide a valid 'memory_id'")
prev_value = existing_memory.payload.get("data")
new_metadata = deepcopy(metadata) if metadata is not None else {}
new_metadata["data"] = data
new_metadata["hash"] = hashlib.md5(data.encode()).hexdigest()
new_metadata["created_at"] = existing_memory.payload.get("created_at")
new_metadata["updated_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
# Preserve session identifiers from existing memory only if not provided in new metadata
if "user_id" not in new_metadata and "user_id" in existing_memory.payload:
new_metadata["user_id"] = existing_memory.payload["user_id"]
if "agent_id" not in new_metadata and "agent_id" in existing_memory.payload:
new_metadata["agent_id"] = existing_memory.payload["agent_id"]
if "run_id" not in new_metadata and "run_id" in existing_memory.payload:
new_metadata["run_id"] = existing_memory.payload["run_id"]
if "actor_id" not in new_metadata and "actor_id" in existing_memory.payload:
new_metadata["actor_id"] = existing_memory.payload["actor_id"]
if "role" not in new_metadata and "role" in existing_memory.payload:
new_metadata["role"] = existing_memory.payload["role"]
if data in existing_embeddings:
embeddings = existing_embeddings[data]
else:
embeddings = self.embedding_model.embed(data, "update")
self.vector_store.update(
vector_id=memory_id,
vector=embeddings,
payload=new_metadata,
)
logger.info(f"Updating memory with ID {memory_id=} with {data=}")
self.db.add_history(
memory_id,
prev_value,
data,
"UPDATE",
created_at=new_metadata["created_at"],
updated_at=new_metadata["updated_at"],
actor_id=new_metadata.get("actor_id"),
role=new_metadata.get("role"),
)
return memory_id
def _delete_memory(self, memory_id):
logger.info(f"Deleting memory with {memory_id=}")
existing_memory = self.vector_store.get(vector_id=memory_id)
prev_value = existing_memory.payload.get("data", "")
self.vector_store.delete(vector_id=memory_id)
self.db.add_history(
memory_id,
prev_value,
None,
"DELETE",
actor_id=existing_memory.payload.get("actor_id"),
role=existing_memory.payload.get("role"),
is_deleted=1,
)
return memory_id
def reset(self):
logger.warning("Resetting all memories")
if hasattr(self.db, "connection") and self.db.connection:
self.db.connection.execute("DROP TABLE IF EXISTS history")
self.db.connection.close()
self.db = SQLiteManager(self.config.history_db_path)
if hasattr(self.vector_store, "reset"):
self.vector_store = VectorStoreFactory.reset(self.vector_store)
else:
logger.warning("Vector store does not support reset. Skipping.")
self.vector_store.delete_col()
self.vector_store = VectorStoreFactory.create(
self.config.vector_store.provider, self.config.vector_store.config
)
capture_event("mem0.reset", self, {"sync_type": "sync"})
def chat(self, query):
raise NotImplementedError("Chat function not implemented yet.")
class AsyncMemory(MemoryBase):
def __init__(self, config: MemoryConfig = MemoryConfig()):
self.config = config
self.embedding_model = EmbedderFactory.create(
self.config.embedder.provider,
self.config.embedder.config,
self.config.vector_store.config,
)
self.vector_store = VectorStoreFactory.create(
self.config.vector_store.provider, self.config.vector_store.config
)
self.llm = LlmFactory.create(self.config.llm.provider, self.config.llm.config)
self.db = SQLiteManager(self.config.history_db_path)
self.collection_name = self.config.vector_store.config.collection_name
self.api_version = self.config.version
# Initialize reranker if configured
self.reranker = None
if config.reranker:
self.reranker = RerankerFactory.create(
config.reranker.provider,
config.reranker.config
)
self.enable_graph = False
if self.config.graph_store.config:
provider = self.config.graph_store.provider
self.graph = GraphStoreFactory.create(provider, self.config)
self.enable_graph = True
else:
self.graph = None
if MEM0_TELEMETRY:
telemetry_config = _safe_deepcopy_config(self.config.vector_store.config)
telemetry_config.collection_name = "mem0migrations"
if self.config.vector_store.provider in ["faiss", "qdrant"]:
provider_path = f"migrations_{self.config.vector_store.provider}"
telemetry_config.path = os.path.join(mem0_dir, provider_path)
os.makedirs(telemetry_config.path, exist_ok=True)
self._telemetry_vector_store = VectorStoreFactory.create(self.config.vector_store.provider, telemetry_config)
capture_event("mem0.init", self, {"sync_type": "async"})
@classmethod
async def from_config(cls, config_dict: Dict[str, Any]):
try:
config = cls._process_config(config_dict)
config = MemoryConfig(**config_dict)
except ValidationError as e:
logger.error(f"Configuration validation error: {e}")
raise
return cls(config)
@staticmethod
def _process_config(config_dict: Dict[str, Any]) -> Dict[str, Any]:
if "graph_store" in config_dict:
if "vector_store" not in config_dict and "embedder" in config_dict:
config_dict["vector_store"] = {}
config_dict["vector_store"]["config"] = {}
config_dict["vector_store"]["config"]["embedding_model_dims"] = config_dict["embedder"]["config"][
"embedding_dims"
]
try:
return config_dict
except ValidationError as e:
logger.error(f"Configuration validation error: {e}")
raise
def _should_use_agent_memory_extraction(self, messages, metadata):
# Check if agent_id is present in metadata
has_agent_id = metadata.get("agent_id") is not None
# Check if there are assistant role messages
has_assistant_messages = any(msg.get("role") == "assistant" for msg in messages)
# Use agent memory extraction if agent_id is present and there are assistant messages
return has_agent_id and has_assistant_messages
async def add(
self,
messages,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
metadata: Optional[Dict[str, Any]] = None,
infer: bool = True,
memory_type: Optional[str] = None,
prompt: Optional[str] = None,
llm=None,
):
processed_metadata, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_metadata=metadata
)
if memory_type is not None and memory_type != MemoryType.PROCEDURAL.value:
raise ValueError(
f"Invalid 'memory_type'. Please pass {MemoryType.PROCEDURAL.value} to create procedural memories."
)
if isinstance(messages, str):
messages = [{"role": "user", "content": messages}]
elif isinstance(messages, dict):
messages = [messages]
elif not isinstance(messages, list):
raise Mem0ValidationError(
message="messages must be str, dict, or list[dict]",
error_code="VALIDATION_003",
details={"provided_type": type(messages).__name__, "valid_types": ["str", "dict", "list[dict]"]},
suggestion="Convert your input to a string, dictionary, or list of dictionaries."
)
if agent_id is not None and memory_type == MemoryType.PROCEDURAL.value:
results = await self._create_procedural_memory(
messages, metadata=processed_metadata, prompt=prompt, llm=llm
)
return results
if self.config.llm.config.get("enable_vision"):
messages = parse_vision_messages(messages, self.llm, self.config.llm.config.get("vision_details"))
else:
messages = parse_vision_messages(messages)
vector_store_task = asyncio.create_task(
self._add_to_vector_store(messages, processed_metadata, effective_filters, infer)
)
graph_task = asyncio.create_task(self._add_to_graph(messages, effective_filters))
vector_store_result, graph_result = await asyncio.gather(vector_store_task, graph_task)
if self.enable_graph:
return {
"results": vector_store_result,
"relations": graph_result,
}
return {"results": vector_store_result}
async def _add_to_vector_store(
self,
messages: list,
metadata: dict,
effective_filters: dict,
infer: bool,
):
if not infer:
returned_memories = []
for message_dict in messages:
if (
not isinstance(message_dict, dict)
or message_dict.get("role") is None
or message_dict.get("content") is None
):
logger.warning(f"Skipping invalid message format (async): {message_dict}")
continue
if message_dict["role"] == "system":
continue
per_msg_meta = deepcopy(metadata)
per_msg_meta["role"] = message_dict["role"]
actor_name = message_dict.get("name")
if actor_name:
per_msg_meta["actor_id"] = actor_name
msg_content = message_dict["content"]
msg_embeddings = await asyncio.to_thread(self.embedding_model.embed, msg_content, "add")
mem_id = await self._create_memory(msg_content, msg_embeddings, per_msg_meta)
returned_memories.append(
{
"id": mem_id,
"memory": msg_content,
"event": "ADD",
"actor_id": actor_name if actor_name else None,
"role": message_dict["role"],
}
)
return returned_memories
parsed_messages = parse_messages(messages)
if self.config.custom_fact_extraction_prompt:
system_prompt = self.config.custom_fact_extraction_prompt
user_prompt = f"Input:\n{parsed_messages}"
else:
# Determine if this should use agent memory extraction based on agent_id presence
# and role types in messages
is_agent_memory = self._should_use_agent_memory_extraction(messages, metadata)
system_prompt, user_prompt = get_fact_retrieval_messages(parsed_messages, is_agent_memory)
# Ensure 'json' appears in prompts for json_object response format compatibility
system_prompt, user_prompt = ensure_json_instruction(system_prompt, user_prompt)
response = await asyncio.to_thread(
self.llm.generate_response,
messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}],
response_format={"type": "json_object"},
)
try:
response = remove_code_blocks(response)
if not response.strip():
new_retrieved_facts = []
else:
try:
# First try direct JSON parsing
new_retrieved_facts = json.loads(response)["facts"]
except json.JSONDecodeError:
# Try extracting JSON from response using built-in function
extracted_json = extract_json(response)
new_retrieved_facts = json.loads(extracted_json)["facts"]
new_retrieved_facts = normalize_facts(new_retrieved_facts)
except Exception as e:
logger.error(f"Error in new_retrieved_facts: {e}")
new_retrieved_facts = []
if not new_retrieved_facts:
logger.debug("No new facts retrieved from input. Skipping memory update LLM call.")
retrieved_old_memory = []
new_message_embeddings = {}
# Search for existing memories using the provided session identifiers
# Use all available session identifiers for accurate memory retrieval
search_filters = {}
if effective_filters.get("user_id"):
search_filters["user_id"] = effective_filters["user_id"]
if effective_filters.get("agent_id"):
search_filters["agent_id"] = effective_filters["agent_id"]
if effective_filters.get("run_id"):
search_filters["run_id"] = effective_filters["run_id"]
async def process_fact_for_search(new_mem_content):
embeddings = await asyncio.to_thread(self.embedding_model.embed, new_mem_content, "add")
new_message_embeddings[new_mem_content] = embeddings
existing_mems = await asyncio.to_thread(
self.vector_store.search,
query=new_mem_content,
vectors=embeddings,
limit=5,
filters=search_filters,
)
return [{"id": mem.id, "text": mem.payload.get("data", "")} for mem in existing_mems]
search_tasks = [process_fact_for_search(fact) for fact in new_retrieved_facts]
search_results_list = await asyncio.gather(*search_tasks)
for result_group in search_results_list:
retrieved_old_memory.extend(result_group)
unique_data = {}
for item in retrieved_old_memory:
unique_data[item["id"]] = item
retrieved_old_memory = list(unique_data.values())
logger.info(f"Total existing memories: {len(retrieved_old_memory)}")
temp_uuid_mapping = {}
for idx, item in enumerate(retrieved_old_memory):
temp_uuid_mapping[str(idx)] = item["id"]
retrieved_old_memory[idx]["id"] = str(idx)
if new_retrieved_facts:
function_calling_prompt = get_update_memory_messages(
retrieved_old_memory, new_retrieved_facts, self.config.custom_update_memory_prompt
)
try:
response = await asyncio.to_thread(
self.llm.generate_response,
messages=[{"role": "user", "content": function_calling_prompt}],
response_format={"type": "json_object"},
)
except Exception as e:
logger.error(f"Error in new memory actions response: {e}")
response = ""
try:
if not response or not response.strip():
logger.warning("Empty response from LLM, no memories to extract")
new_memories_with_actions = {}
else:
response = remove_code_blocks(response)
new_memories_with_actions = json.loads(response)
except Exception as e:
logger.error(f"Invalid JSON response: {e}")
new_memories_with_actions = {}
else:
new_memories_with_actions = {}
returned_memories = []
try:
memory_tasks = []
for resp in new_memories_with_actions.get("memory", []):
logger.info(resp)
try:
action_text = resp.get("text")
if not action_text:
continue
event_type = resp.get("event")
if event_type == "ADD":
task = asyncio.create_task(
self._create_memory(
data=action_text,
existing_embeddings=new_message_embeddings,
metadata=deepcopy(metadata),
)
)
memory_tasks.append((task, resp, "ADD", None))
elif event_type == "UPDATE":
task = asyncio.create_task(
self._update_memory(
memory_id=temp_uuid_mapping[resp["id"]],
data=action_text,
existing_embeddings=new_message_embeddings,
metadata=deepcopy(metadata),
)
)
memory_tasks.append((task, resp, "UPDATE", temp_uuid_mapping[resp["id"]]))
elif event_type == "DELETE":
task = asyncio.create_task(self._delete_memory(memory_id=temp_uuid_mapping[resp.get("id")]))
memory_tasks.append((task, resp, "DELETE", temp_uuid_mapping[resp.get("id")]))
elif event_type == "NONE":
# Even if content doesn't need updating, update session IDs if provided
memory_id = temp_uuid_mapping.get(resp.get("id"))
if memory_id and (metadata.get("agent_id") or metadata.get("run_id")):
# Create async task to update only the session identifiers
async def update_session_ids(mem_id, meta):
existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=mem_id)
updated_metadata = deepcopy(existing_memory.payload)
if meta.get("agent_id"):
updated_metadata["agent_id"] = meta["agent_id"]
if meta.get("run_id"):
updated_metadata["run_id"] = meta["run_id"]
updated_metadata["updated_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
await asyncio.to_thread(
self.vector_store.update,
vector_id=mem_id,
vector=None, # Keep same embeddings
payload=updated_metadata,
)
logger.info(f"Updated session IDs for memory {mem_id} (async)")
task = asyncio.create_task(update_session_ids(memory_id, metadata))
memory_tasks.append((task, resp, "NONE", memory_id))
else:
logger.info("NOOP for Memory (async).")
except Exception as e:
logger.error(f"Error processing memory action (async): {resp}, Error: {e}")
for task, resp, event_type, mem_id in memory_tasks:
try:
result_id = await task
if event_type == "ADD":
returned_memories.append({"id": result_id, "memory": resp.get("text"), "event": event_type})
elif event_type == "UPDATE":
returned_memories.append(
{
"id": mem_id,
"memory": resp.get("text"),
"event": event_type,
"previous_memory": resp.get("old_memory"),
}
)
elif event_type == "DELETE":
returned_memories.append({"id": mem_id, "memory": resp.get("text"), "event": event_type})
except Exception as e:
logger.error(f"Error awaiting memory task (async): {e}")
except Exception as e:
logger.error(f"Error in memory processing loop (async): {e}")
keys, encoded_ids = process_telemetry_filters(effective_filters)
capture_event(
"mem0.add",
self,
{"version": self.api_version, "keys": keys, "encoded_ids": encoded_ids, "sync_type": "async"},
)
return returned_memories
async def _add_to_graph(self, messages, filters):
added_entities = []
if self.enable_graph:
if filters.get("user_id") is None:
filters["user_id"] = "user"
data = "\n".join([msg["content"] for msg in messages if "content" in msg and msg["role"] != "system"])
added_entities = await asyncio.to_thread(self.graph.add, data, filters)
return added_entities
async def get(self, memory_id):
capture_event("mem0.get", self, {"memory_id": memory_id, "sync_type": "async"})
memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
if not memory:
return None
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
result_item = MemoryItem(
id=memory.id,
memory=memory.payload.get("data", ""),
hash=memory.payload.get("hash"),
created_at=memory.payload.get("created_at"),
updated_at=memory.payload.get("updated_at"),
).model_dump()
for key in promoted_payload_keys:
if key in memory.payload:
result_item[key] = memory.payload[key]
additional_metadata = {k: v for k, v in memory.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
result_item["metadata"] = additional_metadata
return result_item
async def get_all(
self,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
filters: Optional[Dict[str, Any]] = None,
limit: int = 100,
):
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
)
if not any(key in effective_filters for key in ("user_id", "agent_id", "run_id")):
raise ValueError(
"When 'conversation_id' is not provided (classic mode), "
"at least one of 'user_id', 'agent_id', or 'run_id' must be specified for get_all."
)
keys, encoded_ids = process_telemetry_filters(effective_filters)
capture_event(
"mem0.get_all", self, {"limit": limit, "keys": keys, "encoded_ids": encoded_ids, "sync_type": "async"}
)
vector_store_task = asyncio.create_task(self._get_all_from_vector_store(effective_filters, limit))
graph_task = None
if self.enable_graph:
graph_get_all = getattr(self.graph, "get_all", None)
if callable(graph_get_all):
if asyncio.iscoroutinefunction(graph_get_all):
graph_task = asyncio.create_task(graph_get_all(effective_filters, limit))
else:
graph_task = asyncio.create_task(asyncio.to_thread(graph_get_all, effective_filters, limit))
results_dict = {}
if graph_task:
vector_store_result, graph_entities_result = await asyncio.gather(vector_store_task, graph_task)
results_dict.update({"results": vector_store_result, "relations": graph_entities_result})
else:
results_dict.update({"results": await vector_store_task})
return results_dict
async def _get_all_from_vector_store(self, filters, limit):
memories_result = await asyncio.to_thread(self.vector_store.list, filters=filters, limit=limit)
# Handle different vector store return formats by inspecting first element
if isinstance(memories_result, (tuple, list)) and len(memories_result) > 0:
first_element = memories_result[0]
# If first element is a container, unwrap one level
if isinstance(first_element, (list, tuple)):
actual_memories = first_element
else:
# First element is a memory object, structure is already flat
actual_memories = memories_result
else:
actual_memories = memories_result
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
formatted_memories = []
for mem in actual_memories:
memory_item_dict = MemoryItem(
id=mem.id,
memory=mem.payload.get("data", ""),
hash=mem.payload.get("hash"),
created_at=mem.payload.get("created_at"),
updated_at=mem.payload.get("updated_at"),
).model_dump(exclude={"score"})
for key in promoted_payload_keys:
if key in mem.payload:
memory_item_dict[key] = mem.payload[key]
additional_metadata = {k: v for k, v in mem.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
memory_item_dict["metadata"] = additional_metadata
formatted_memories.append(memory_item_dict)
return formatted_memories
async def search(
self,
query: str,
*,
user_id: Optional[str] = None,
agent_id: Optional[str] = None,
run_id: Optional[str] = None,
limit: int = 100,
filters: Optional[Dict[str, Any]] = None,
threshold: Optional[float] = None,
metadata_filters: Optional[Dict[str, Any]] = None,
rerank: bool = True,
):
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
)
if not any(key in effective_filters for key in ("user_id", "agent_id", "run_id")):
raise ValueError("at least one of 'user_id', 'agent_id', or 'run_id' must be specified ")
# Apply enhanced metadata filtering if advanced operators are detected
if filters and self._has_advanced_operators(filters):
processed_filters = self._process_metadata_filters(filters)
effective_filters.update(processed_filters)
elif filters:
# Simple filters, merge directly
effective_filters.update(filters)
keys, encoded_ids = process_telemetry_filters(effective_filters)
capture_event(
"mem0.search",
self,
{
"limit": limit,
"version": self.api_version,
"keys": keys,
"encoded_ids": encoded_ids,
"sync_type": "async",
"threshold": threshold,
"advanced_filters": bool(filters and self._has_advanced_operators(filters)),
},
)
vector_store_task = asyncio.create_task(self._search_vector_store(query, effective_filters, limit, threshold))
graph_task = None
if self.enable_graph:
if hasattr(self.graph.search, "__await__"): # Check if graph search is async
graph_task = asyncio.create_task(self.graph.search(query, effective_filters, limit))
else:
graph_task = asyncio.create_task(asyncio.to_thread(self.graph.search, query, effective_filters, limit))
if graph_task:
original_memories, graph_entities = await asyncio.gather(vector_store_task, graph_task)
else:
original_memories = await vector_store_task
graph_entities = None
# Apply reranking if enabled and reranker is available
if rerank and self.reranker and original_memories:
try:
# Run reranking in thread pool to avoid blocking async loop
reranked_memories = await asyncio.to_thread(
self.reranker.rerank, query, original_memories, limit
)
original_memories = reranked_memories
except Exception as e:
logger.warning(f"Reranking failed, using original results: {e}")
if self.enable_graph:
return {"results": original_memories, "relations": graph_entities}
return {"results": original_memories}
def _process_metadata_filters(self, metadata_filters: Dict[str, Any]) -> Dict[str, Any]:
processed_filters = {}
def process_condition(key: str, condition: Any) -> Dict[str, Any]:
if not isinstance(condition, dict):
# Simple equality: {"key": "value"}
if condition == "*":
# Wildcard: match everything for this field (implementation depends on vector store)
return {key: "*"}
return {key: condition}
result = {}
for operator, value in condition.items():
# Map platform operators to universal format that can be translated by each vector store
operator_map = {
"eq": "eq", "ne": "ne", "gt": "gt", "gte": "gte",
"lt": "lt", "lte": "lte", "in": "in", "nin": "nin",
"contains": "contains", "icontains": "icontains"
}
if operator in operator_map:
result[key] = {operator_map[operator]: value}
else:
raise ValueError(f"Unsupported metadata filter operator: {operator}")
return result
for key, value in metadata_filters.items():
if key == "AND":
# Logical AND: combine multiple conditions
if not isinstance(value, list):
raise ValueError("AND operator requires a list of conditions")
for condition in value:
for sub_key, sub_value in condition.items():
processed_filters.update(process_condition(sub_key, sub_value))
elif key == "OR":
# Logical OR: Pass through to vector store for implementation-specific handling
if not isinstance(value, list) or not value:
raise ValueError("OR operator requires a non-empty list of conditions")
# Store OR conditions in a way that vector stores can interpret
processed_filters["$or"] = []
for condition in value:
or_condition = {}
for sub_key, sub_value in condition.items():
or_condition.update(process_condition(sub_key, sub_value))
processed_filters["$or"].append(or_condition)
elif key == "NOT":
# Logical NOT: Pass through to vector store for implementation-specific handling
if not isinstance(value, list) or not value:
raise ValueError("NOT operator requires a non-empty list of conditions")
processed_filters["$not"] = []
for condition in value:
not_condition = {}
for sub_key, sub_value in condition.items():
not_condition.update(process_condition(sub_key, sub_value))
processed_filters["$not"].append(not_condition)
else:
processed_filters.update(process_condition(key, value))
return processed_filters
def _has_advanced_operators(self, filters: Dict[str, Any]) -> bool:
if not isinstance(filters, dict):
return False
for key, value in filters.items():
# Check for platform-style logical operators
if key in ["AND", "OR", "NOT"]:
return True
# Check for comparison operators (without $ prefix for universal compatibility)
if isinstance(value, dict):
for op in value.keys():
if op in ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "icontains"]:
return True
# Check for wildcard values
if value == "*":
return True
return False
async def _search_vector_store(self, query, filters, limit, threshold: Optional[float] = None):
embeddings = await asyncio.to_thread(self.embedding_model.embed, query, "search")
memories = await asyncio.to_thread(
self.vector_store.search, query=query, vectors=embeddings, limit=limit, filters=filters
)
promoted_payload_keys = [
"user_id",
"agent_id",
"run_id",
"actor_id",
"role",
]
core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", *promoted_payload_keys}
original_memories = []
for mem in memories:
memory_item_dict = MemoryItem(
id=mem.id,
memory=mem.payload.get("data", ""),
hash=mem.payload.get("hash"),
created_at=mem.payload.get("created_at"),
updated_at=mem.payload.get("updated_at"),
score=mem.score,
).model_dump()
for key in promoted_payload_keys:
if key in mem.payload:
memory_item_dict[key] = mem.payload[key]
additional_metadata = {k: v for k, v in mem.payload.items() if k not in core_and_promoted_keys}
if additional_metadata:
memory_item_dict["metadata"] = additional_metadata
if threshold is None or mem.score >= threshold:
original_memories.append(memory_item_dict)
return original_memories
async def update(self, memory_id, data):
capture_event("mem0.update", self, {"memory_id": memory_id, "sync_type": "async"})
embeddings = await asyncio.to_thread(self.embedding_model.embed, data, "update")
existing_embeddings = {data: embeddings}
await self._update_memory(memory_id, data, existing_embeddings)
return {"message": "Memory updated successfully!"}
async def delete(self, memory_id):
capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "async"})
await self._delete_memory(memory_id)
return {"message": "Memory deleted successfully!"}
async def delete_all(self, user_id=None, agent_id=None, run_id=None):
filters = {}
if user_id:
filters["user_id"] = user_id
if agent_id:
filters["agent_id"] = agent_id
if run_id:
filters["run_id"] = run_id
if not filters:
raise ValueError(
"At least one filter is required to delete all memories. If you want to delete all memories, use the `reset()` method."
)
keys, encoded_ids = process_telemetry_filters(filters)
capture_event("mem0.delete_all", self, {"keys": keys, "encoded_ids": encoded_ids, "sync_type": "async"})
memories = await asyncio.to_thread(self.vector_store.list, filters=filters)
delete_tasks = []
for memory in memories[0]:
delete_tasks.append(self._delete_memory(memory.id))
await asyncio.gather(*delete_tasks)
logger.info(f"Deleted {len(memories[0])} memories")
if self.enable_graph:
await asyncio.to_thread(self.graph.delete_all, filters)
return {"message": "Memories deleted successfully!"}
async def history(self, memory_id):
capture_event("mem0.history", self, {"memory_id": memory_id, "sync_type": "async"})
return await asyncio.to_thread(self.db.get_history, memory_id)
async def _create_memory(self, data, existing_embeddings, metadata=None):
logger.debug(f"Creating memory with {data=}")
if data in existing_embeddings:
embeddings = existing_embeddings[data]
else:
embeddings = await asyncio.to_thread(self.embedding_model.embed, data, memory_action="add")
memory_id = str(uuid.uuid4())
metadata = metadata or {}
metadata["data"] = data
metadata["hash"] = hashlib.md5(data.encode()).hexdigest()
metadata["created_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
await asyncio.to_thread(
self.vector_store.insert,
vectors=[embeddings],
ids=[memory_id],
payloads=[metadata],
)
await asyncio.to_thread(
self.db.add_history,
memory_id,
None,
data,
"ADD",
created_at=metadata.get("created_at"),
actor_id=metadata.get("actor_id"),
role=metadata.get("role"),
)
return memory_id
async def _create_procedural_memory(self, messages, metadata=None, llm=None, prompt=None):
try:
from langchain_core.messages.utils import (
convert_to_messages, # type: ignore
)
except Exception:
logger.error(
"Import error while loading langchain-core. Please install 'langchain-core' to use procedural memory."
)
raise
logger.info("Creating procedural memory")
parsed_messages = [
{"role": "system", "content": prompt or PROCEDURAL_MEMORY_SYSTEM_PROMPT},
*messages,
{"role": "user", "content": "Create procedural memory of the above conversation."},
]
try:
if llm is not None:
parsed_messages = convert_to_messages(parsed_messages)
response = await asyncio.to_thread(llm.invoke, input=parsed_messages)
procedural_memory = response.content
else:
procedural_memory = await asyncio.to_thread(self.llm.generate_response, messages=parsed_messages)
procedural_memory = remove_code_blocks(procedural_memory)
except Exception as e:
logger.error(f"Error generating procedural memory summary: {e}")
raise
if metadata is None:
raise ValueError("Metadata cannot be done for procedural memory.")
metadata["memory_type"] = MemoryType.PROCEDURAL.value
embeddings = await asyncio.to_thread(self.embedding_model.embed, procedural_memory, memory_action="add")
memory_id = await self._create_memory(procedural_memory, {procedural_memory: embeddings}, metadata=metadata)
capture_event("mem0._create_procedural_memory", self, {"memory_id": memory_id, "sync_type": "async"})
result = {"results": [{"id": memory_id, "memory": procedural_memory, "event": "ADD"}]}
return result
async def _update_memory(self, memory_id, data, existing_embeddings, metadata=None):
logger.info(f"Updating memory with {data=}")
try:
existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
except Exception:
logger.error(f"Error getting memory with ID {memory_id} during update.")
raise ValueError(f"Error getting memory with ID {memory_id}. Please provide a valid 'memory_id'")
prev_value = existing_memory.payload.get("data")
new_metadata = deepcopy(metadata) if metadata is not None else {}
new_metadata["data"] = data
new_metadata["hash"] = hashlib.md5(data.encode()).hexdigest()
new_metadata["created_at"] = existing_memory.payload.get("created_at")
new_metadata["updated_at"] = datetime.now(pytz.timezone("US/Pacific")).isoformat()
# Preserve session identifiers from existing memory only if not provided in new metadata
if "user_id" not in new_metadata and "user_id" in existing_memory.payload:
new_metadata["user_id"] = existing_memory.payload["user_id"]
if "agent_id" not in new_metadata and "agent_id" in existing_memory.payload:
new_metadata["agent_id"] = existing_memory.payload["agent_id"]
if "run_id" not in new_metadata and "run_id" in existing_memory.payload:
new_metadata["run_id"] = existing_memory.payload["run_id"]
if "actor_id" not in new_metadata and "actor_id" in existing_memory.payload:
new_metadata["actor_id"] = existing_memory.payload["actor_id"]
if "role" not in new_metadata and "role" in existing_memory.payload:
new_metadata["role"] = existing_memory.payload["role"]
if data in existing_embeddings:
embeddings = existing_embeddings[data]
else:
embeddings = await asyncio.to_thread(self.embedding_model.embed, data, "update")
await asyncio.to_thread(
self.vector_store.update,
vector_id=memory_id,
vector=embeddings,
payload=new_metadata,
)
logger.info(f"Updating memory with ID {memory_id=} with {data=}")
await asyncio.to_thread(
self.db.add_history,
memory_id,
prev_value,
data,
"UPDATE",
created_at=new_metadata["created_at"],
updated_at=new_metadata["updated_at"],
actor_id=new_metadata.get("actor_id"),
role=new_metadata.get("role"),
)
return memory_id
async def _delete_memory(self, memory_id):
logger.info(f"Deleting memory with {memory_id=}")
existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
prev_value = existing_memory.payload.get("data", "")
await asyncio.to_thread(self.vector_store.delete, vector_id=memory_id)
await asyncio.to_thread(
self.db.add_history,
memory_id,
prev_value,
None,
"DELETE",
actor_id=existing_memory.payload.get("actor_id"),
role=existing_memory.payload.get("role"),
is_deleted=1,
)
return memory_id
async def reset(self):
logger.warning("Resetting all memories")
await asyncio.to_thread(self.vector_store.delete_col)
gc.collect()
if hasattr(self.vector_store, "client") and hasattr(self.vector_store.client, "close"):
await asyncio.to_thread(self.vector_store.client.close)
if hasattr(self.db, "connection") and self.db.connection:
await asyncio.to_thread(lambda: self.db.connection.execute("DROP TABLE IF EXISTS history"))
await asyncio.to_thread(self.db.connection.close)
self.db = SQLiteManager(self.config.history_db_path)
self.vector_store = VectorStoreFactory.create(
self.config.vector_store.provider, self.config.vector_store.config
)
capture_event("mem0.reset", self, {"sync_type": "async"})
async def chat(self, query):
raise NotImplementedError("Chat function not implemented yet.") | --- +++ @@ -52,6 +52,7 @@
def _safe_deepcopy_config(config):
+ """Safely deepcopy config, falling back to JSON serialization for non-serializable objects."""
try:
return deepcopy(config)
except Exception as e:
@@ -94,6 +95,40 @@ input_metadata: Optional[Dict[str, Any]] = None,
input_filters: Optional[Dict[str, Any]] = None,
) -> tuple[Dict[str, Any], Dict[str, Any]]:
+ """
+ Constructs metadata for storage and filters for querying based on session and actor identifiers.
+
+ This helper supports multiple session identifiers (`user_id`, `agent_id`, and/or `run_id`)
+ for flexible session scoping and optionally narrows queries to a specific `actor_id`. It returns two dicts:
+
+ 1. `base_metadata_template`: Used as a template for metadata when storing new memories.
+ It includes all provided session identifier(s) and any `input_metadata`.
+ 2. `effective_query_filters`: Used for querying existing memories. It includes all
+ provided session identifier(s), any `input_filters`, and a resolved actor
+ identifier for targeted filtering if specified by any actor-related inputs.
+
+ Actor filtering precedence: explicit `actor_id` arg → `filters["actor_id"]`
+ This resolved actor ID is used for querying but is not added to `base_metadata_template`,
+ as the actor for storage is typically derived from message content at a later stage.
+
+ Args:
+ user_id (Optional[str]): User identifier, for session scoping.
+ agent_id (Optional[str]): Agent identifier, for session scoping.
+ run_id (Optional[str]): Run identifier, for session scoping.
+ actor_id (Optional[str]): Explicit actor identifier, used as a potential source for
+ actor-specific filtering. See actor resolution precedence in the main description.
+ input_metadata (Optional[Dict[str, Any]]): Base dictionary to be augmented with
+ session identifiers for the storage metadata template. Defaults to an empty dict.
+ input_filters (Optional[Dict[str, Any]]): Base dictionary to be augmented with
+ session and actor identifiers for query filters. Defaults to an empty dict.
+
+ Returns:
+ tuple[Dict[str, Any], Dict[str, Any]]: A tuple containing:
+ - base_metadata_template (Dict[str, Any]): Metadata template for storing memories,
+ scoped to the provided session(s).
+ - effective_query_filters (Dict[str, Any]): Filters for querying memories,
+ scoped to the provided session(s) and potentially a resolved actor.
+ """
base_metadata_template = deepcopy(input_metadata) if input_metadata else {}
effective_query_filters = deepcopy(input_filters) if input_filters else {}
@@ -226,6 +261,17 @@ raise
def _should_use_agent_memory_extraction(self, messages, metadata):
+ """Determine whether to use agent memory extraction based on the logic:
+ - If agent_id is present and messages contain assistant role -> True
+ - Otherwise -> False
+
+ Args:
+ messages: List of message dictionaries
+ metadata: Metadata containing user_id, agent_id, etc.
+
+ Returns:
+ bool: True if should use agent memory extraction, False for user memory extraction
+ """
# Check if agent_id is present in metadata
has_agent_id = metadata.get("agent_id") is not None
@@ -247,6 +293,43 @@ memory_type: Optional[str] = None,
prompt: Optional[str] = None,
):
+ """
+ Create a new memory.
+
+ Adds new memories scoped to a single session id (e.g. `user_id`, `agent_id`, or `run_id`). One of those ids is required.
+
+ Args:
+ messages (str or List[Dict[str, str]]): The message content or list of messages
+ (e.g., `[{"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi"}]`)
+ to be processed and stored.
+ user_id (str, optional): ID of the user creating the memory. Defaults to None.
+ agent_id (str, optional): ID of the agent creating the memory. Defaults to None.
+ run_id (str, optional): ID of the run creating the memory. Defaults to None.
+ metadata (dict, optional): Metadata to store with the memory. Defaults to None.
+ infer (bool, optional): If True (default), an LLM is used to extract key facts from
+ 'messages' and decide whether to add, update, or delete related memories.
+ If False, 'messages' are added as raw memories directly.
+ memory_type (str, optional): Specifies the type of memory. Currently, only
+ `MemoryType.PROCEDURAL.value` ("procedural_memory") is explicitly handled for
+ creating procedural memories (typically requires 'agent_id'). Otherwise, memories
+ are treated as general conversational/factual memories.memory_type (str, optional): Type of memory to create. Defaults to None. By default, it creates the short term memories and long term (semantic and episodic) memories. Pass "procedural_memory" to create procedural memories.
+ prompt (str, optional): Prompt to use for the memory creation. Defaults to None.
+
+
+ Returns:
+ dict: A dictionary containing the result of the memory addition operation, typically
+ including a list of memory items affected (added, updated) under a "results" key,
+ and potentially "relations" if graph store is enabled.
+ Example for v1.1+: `{"results": [{"id": "...", "memory": "...", "event": "ADD"}]}`
+
+ Raises:
+ Mem0ValidationError: If input validation fails (invalid memory_type, messages format, etc.).
+ VectorStoreError: If vector store operations fail.
+ GraphStoreError: If graph store operations fail.
+ EmbeddingError: If embedding generation fails.
+ LLMError: If LLM operations fail.
+ DatabaseError: If database operations fail.
+ """
processed_metadata, effective_filters = _build_filters_and_metadata(
user_id=user_id,
@@ -532,6 +615,15 @@ return added_entities
def get(self, memory_id):
+ """
+ Retrieve a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to retrieve.
+
+ Returns:
+ dict: Retrieved memory.
+ """
capture_event("mem0.get", self, {"memory_id": memory_id, "sync_type": "sync"})
memory = self.vector_store.get(vector_id=memory_id)
if not memory:
@@ -574,6 +666,24 @@ filters: Optional[Dict[str, Any]] = None,
limit: int = 100,
):
+ """
+ List all memories.
+
+ Args:
+ user_id (str, optional): user id
+ agent_id (str, optional): agent id
+ run_id (str, optional): run id
+ filters (dict, optional): Additional custom key-value filters to apply to the search.
+ These are merged with the ID-based scoping filters. For example,
+ `filters={"actor_id": "some_user"}`.
+ limit (int, optional): The maximum number of memories to return. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing a list of memories under the "results" key,
+ and potentially "relations" if graph store is enabled. For API v1.0,
+ it might return a direct list (see deprecation warning).
+ Example for v1.1+: `{"results": [{"id": "...", "memory": "...", ...}]}`
+ """
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
@@ -664,6 +774,38 @@ threshold: Optional[float] = None,
rerank: bool = True,
):
+ """
+ Searches for memories based on a query
+ Args:
+ query (str): Query to search for.
+ user_id (str, optional): ID of the user to search for. Defaults to None.
+ agent_id (str, optional): ID of the agent to search for. Defaults to None.
+ run_id (str, optional): ID of the run to search for. Defaults to None.
+ limit (int, optional): Limit the number of results. Defaults to 100.
+ filters (dict, optional): Legacy filters to apply to the search. Defaults to None.
+ threshold (float, optional): Minimum score for a memory to be included in the results. Defaults to None.
+ filters (dict, optional): Enhanced metadata filtering with operators:
+ - {"key": "value"} - exact match
+ - {"key": {"eq": "value"}} - equals
+ - {"key": {"ne": "value"}} - not equals
+ - {"key": {"in": ["val1", "val2"]}} - in list
+ - {"key": {"nin": ["val1", "val2"]}} - not in list
+ - {"key": {"gt": 10}} - greater than
+ - {"key": {"gte": 10}} - greater than or equal
+ - {"key": {"lt": 10}} - less than
+ - {"key": {"lte": 10}} - less than or equal
+ - {"key": {"contains": "text"}} - contains text
+ - {"key": {"icontains": "text"}} - case-insensitive contains
+ - {"key": "*"} - wildcard match (any value)
+ - {"AND": [filter1, filter2]} - logical AND
+ - {"OR": [filter1, filter2]} - logical OR
+ - {"NOT": [filter1]} - logical NOT
+
+ Returns:
+ dict: A dictionary containing the search results, typically under a "results" key,
+ and potentially "relations" if graph store is enabled.
+ Example for v1.1+: `{"results": [{"id": "...", "memory": "...", "score": 0.8, ...}]}`
+ """
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
)
@@ -721,6 +863,15 @@ return {"results": original_memories}
def _process_metadata_filters(self, metadata_filters: Dict[str, Any]) -> Dict[str, Any]:
+ """
+ Process enhanced metadata filters and convert them to vector store compatible format.
+
+ Args:
+ metadata_filters: Enhanced metadata filters with operators
+
+ Returns:
+ Dict of processed filters compatible with vector store
+ """
processed_filters = {}
def process_condition(key: str, condition: Any) -> Dict[str, Any]:
@@ -781,6 +932,15 @@ return processed_filters
def _has_advanced_operators(self, filters: Dict[str, Any]) -> bool:
+ """
+ Check if filters contain advanced operators that need special processing.
+
+ Args:
+ filters: Dictionary of filters to check
+
+ Returns:
+ bool: True if advanced operators are detected
+ """
if not isinstance(filters, dict):
return False
@@ -837,6 +997,20 @@ return original_memories
def update(self, memory_id, data):
+ """
+ Update a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to update.
+ data (str): New content to update the memory with.
+
+ Returns:
+ dict: Success message indicating the memory was updated.
+
+ Example:
+ >>> m.update(memory_id="mem_123", data="Likes to play tennis on weekends")
+ {'message': 'Memory updated successfully!'}
+ """
capture_event("mem0.update", self, {"memory_id": memory_id, "sync_type": "sync"})
existing_embeddings = {data: self.embedding_model.embed(data, "update")}
@@ -845,11 +1019,25 @@ return {"message": "Memory updated successfully!"}
def delete(self, memory_id):
+ """
+ Delete a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to delete.
+ """
capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "sync"})
self._delete_memory(memory_id)
return {"message": "Memory deleted successfully!"}
def delete_all(self, user_id: Optional[str] = None, agent_id: Optional[str] = None, run_id: Optional[str] = None):
+ """
+ Delete all memories.
+
+ Args:
+ user_id (str, optional): ID of the user to delete memories for. Defaults to None.
+ agent_id (str, optional): ID of the agent to delete memories for. Defaults to None.
+ run_id (str, optional): ID of the run to delete memories for. Defaults to None.
+ """
filters: Dict[str, Any] = {}
if user_id:
filters["user_id"] = user_id
@@ -878,6 +1066,15 @@ return {"message": "Memories deleted successfully!"}
def history(self, memory_id):
+ """
+ Get the history of changes for a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to get history for.
+
+ Returns:
+ list: List of changes for the memory.
+ """
capture_event("mem0.history", self, {"memory_id": memory_id, "sync_type": "sync"})
return self.db.get_history(memory_id)
@@ -910,6 +1107,14 @@ return memory_id
def _create_procedural_memory(self, messages, metadata=None, prompt=None):
+ """
+ Create a procedural memory
+
+ Args:
+ messages (list): List of messages to create a procedural memory from.
+ metadata (dict): Metadata to create a procedural memory from.
+ prompt (str, optional): Prompt to use for the procedural memory creation. Defaults to None.
+ """
logger.info("Creating procedural memory")
parsed_messages = [
@@ -1011,6 +1216,12 @@ return memory_id
def reset(self):
+ """
+ Reset the memory store by:
+ Deletes the vector store collection
+ Resets the database
+ Recreates the vector store with a new client
+ """
logger.warning("Resetting all memories")
if hasattr(self.db, "connection") and self.db.connection:
@@ -1103,6 +1314,17 @@ raise
def _should_use_agent_memory_extraction(self, messages, metadata):
+ """Determine whether to use agent memory extraction based on the logic:
+ - If agent_id is present and messages contain assistant role -> True
+ - Otherwise -> False
+
+ Args:
+ messages: List of message dictionaries
+ metadata: Metadata containing user_id, agent_id, etc.
+
+ Returns:
+ bool: True if should use agent memory extraction, False for user memory extraction
+ """
# Check if agent_id is present in metadata
has_agent_id = metadata.get("agent_id") is not None
@@ -1125,6 +1347,23 @@ prompt: Optional[str] = None,
llm=None,
):
+ """
+ Create a new memory asynchronously.
+
+ Args:
+ messages (str or List[Dict[str, str]]): Messages to store in the memory.
+ user_id (str, optional): ID of the user creating the memory.
+ agent_id (str, optional): ID of the agent creating the memory. Defaults to None.
+ run_id (str, optional): ID of the run creating the memory. Defaults to None.
+ metadata (dict, optional): Metadata to store with the memory. Defaults to None.
+ infer (bool, optional): Whether to infer the memories. Defaults to True.
+ memory_type (str, optional): Type of memory to create. Defaults to None.
+ Pass "procedural_memory" to create procedural memories.
+ prompt (str, optional): Prompt to use for the memory creation. Defaults to None.
+ llm (BaseChatModel, optional): LLM class to use for generating procedural memories. Defaults to None. Useful when user is using LangChain ChatModel.
+ Returns:
+ dict: A dictionary containing the result of the memory addition operation.
+ """
processed_metadata, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_metadata=metadata
)
@@ -1423,6 +1662,15 @@ return added_entities
async def get(self, memory_id):
+ """
+ Retrieve a memory by ID asynchronously.
+
+ Args:
+ memory_id (str): ID of the memory to retrieve.
+
+ Returns:
+ dict: Retrieved memory.
+ """
capture_event("mem0.get", self, {"memory_id": memory_id, "sync_type": "async"})
memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
if not memory:
@@ -1465,6 +1713,24 @@ filters: Optional[Dict[str, Any]] = None,
limit: int = 100,
):
+ """
+ List all memories.
+
+ Args:
+ user_id (str, optional): user id
+ agent_id (str, optional): agent id
+ run_id (str, optional): run id
+ filters (dict, optional): Additional custom key-value filters to apply to the search.
+ These are merged with the ID-based scoping filters. For example,
+ `filters={"actor_id": "some_user"}`.
+ limit (int, optional): The maximum number of memories to return. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing a list of memories under the "results" key,
+ and potentially "relations" if graph store is enabled. For API v1.0,
+ it might return a direct list (see deprecation warning).
+ Example for v1.1+: `{"results": [{"id": "...", "memory": "...", ...}]}`
+ """
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
@@ -1561,6 +1827,38 @@ metadata_filters: Optional[Dict[str, Any]] = None,
rerank: bool = True,
):
+ """
+ Searches for memories based on a query
+ Args:
+ query (str): Query to search for.
+ user_id (str, optional): ID of the user to search for. Defaults to None.
+ agent_id (str, optional): ID of the agent to search for. Defaults to None.
+ run_id (str, optional): ID of the run to search for. Defaults to None.
+ limit (int, optional): Limit the number of results. Defaults to 100.
+ filters (dict, optional): Legacy filters to apply to the search. Defaults to None.
+ threshold (float, optional): Minimum score for a memory to be included in the results. Defaults to None.
+ filters (dict, optional): Enhanced metadata filtering with operators:
+ - {"key": "value"} - exact match
+ - {"key": {"eq": "value"}} - equals
+ - {"key": {"ne": "value"}} - not equals
+ - {"key": {"in": ["val1", "val2"]}} - in list
+ - {"key": {"nin": ["val1", "val2"]}} - not in list
+ - {"key": {"gt": 10}} - greater than
+ - {"key": {"gte": 10}} - greater than or equal
+ - {"key": {"lt": 10}} - less than
+ - {"key": {"lte": 10}} - less than or equal
+ - {"key": {"contains": "text"}} - contains text
+ - {"key": {"icontains": "text"}} - case-insensitive contains
+ - {"key": "*"} - wildcard match (any value)
+ - {"AND": [filter1, filter2]} - logical AND
+ - {"OR": [filter1, filter2]} - logical OR
+ - {"NOT": [filter1]} - logical NOT
+
+ Returns:
+ dict: A dictionary containing the search results, typically under a "results" key,
+ and potentially "relations" if graph store is enabled.
+ Example for v1.1+: `{"results": [{"id": "...", "memory": "...", "score": 0.8, ...}]}`
+ """
_, effective_filters = _build_filters_and_metadata(
user_id=user_id, agent_id=agent_id, run_id=run_id, input_filters=filters
@@ -1624,6 +1922,15 @@ return {"results": original_memories}
def _process_metadata_filters(self, metadata_filters: Dict[str, Any]) -> Dict[str, Any]:
+ """
+ Process enhanced metadata filters and convert them to vector store compatible format.
+
+ Args:
+ metadata_filters: Enhanced metadata filters with operators
+
+ Returns:
+ Dict of processed filters compatible with vector store
+ """
processed_filters = {}
def process_condition(key: str, condition: Any) -> Dict[str, Any]:
@@ -1684,6 +1991,15 @@ return processed_filters
def _has_advanced_operators(self, filters: Dict[str, Any]) -> bool:
+ """
+ Check if filters contain advanced operators that need special processing.
+
+ Args:
+ filters: Dictionary of filters to check
+
+ Returns:
+ bool: True if advanced operators are detected
+ """
if not isinstance(filters, dict):
return False
@@ -1742,6 +2058,20 @@ return original_memories
async def update(self, memory_id, data):
+ """
+ Update a memory by ID asynchronously.
+
+ Args:
+ memory_id (str): ID of the memory to update.
+ data (str): New content to update the memory with.
+
+ Returns:
+ dict: Success message indicating the memory was updated.
+
+ Example:
+ >>> await m.update(memory_id="mem_123", data="Likes to play tennis on weekends")
+ {'message': 'Memory updated successfully!'}
+ """
capture_event("mem0.update", self, {"memory_id": memory_id, "sync_type": "async"})
embeddings = await asyncio.to_thread(self.embedding_model.embed, data, "update")
@@ -1751,11 +2081,25 @@ return {"message": "Memory updated successfully!"}
async def delete(self, memory_id):
+ """
+ Delete a memory by ID asynchronously.
+
+ Args:
+ memory_id (str): ID of the memory to delete.
+ """
capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "async"})
await self._delete_memory(memory_id)
return {"message": "Memory deleted successfully!"}
async def delete_all(self, user_id=None, agent_id=None, run_id=None):
+ """
+ Delete all memories asynchronously.
+
+ Args:
+ user_id (str, optional): ID of the user to delete memories for. Defaults to None.
+ agent_id (str, optional): ID of the agent to delete memories for. Defaults to None.
+ run_id (str, optional): ID of the run to delete memories for. Defaults to None.
+ """
filters = {}
if user_id:
filters["user_id"] = user_id
@@ -1787,6 +2131,15 @@ return {"message": "Memories deleted successfully!"}
async def history(self, memory_id):
+ """
+ Get the history of changes for a memory by ID asynchronously.
+
+ Args:
+ memory_id (str): ID of the memory to get history for.
+
+ Returns:
+ list: List of changes for the memory.
+ """
capture_event("mem0.history", self, {"memory_id": memory_id, "sync_type": "async"})
return await asyncio.to_thread(self.db.get_history, memory_id)
@@ -1824,6 +2177,15 @@ return memory_id
async def _create_procedural_memory(self, messages, metadata=None, llm=None, prompt=None):
+ """
+ Create a procedural memory asynchronously
+
+ Args:
+ messages (list): List of messages to create a procedural memory from.
+ metadata (dict): Metadata to create a procedural memory from.
+ llm (llm, optional): LLM to use for the procedural memory creation. Defaults to None.
+ prompt (str, optional): Prompt to use for the procedural memory creation. Defaults to None.
+ """
try:
from langchain_core.messages.utils import (
convert_to_messages, # type: ignore
@@ -1944,6 +2306,12 @@ return memory_id
async def reset(self):
+ """
+ Reset the memory store asynchronously by:
+ Deletes the vector store collection
+ Resets the database
+ Recreates the vector store with a new client
+ """
logger.warning("Resetting all memories")
await asyncio.to_thread(self.vector_store.delete_col)
@@ -1964,4 +2332,4 @@ capture_event("mem0.reset", self, {"sync_type": "async"})
async def chat(self, query):
- raise NotImplementedError("Chat function not implemented yet.")+ raise NotImplementedError("Chat function not implemented yet.")
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/memory/main.py |
Create docstrings for all classes and functions | from abc import ABC, abstractmethod
class MemoryBase(ABC):
@abstractmethod
def get(self, memory_id):
pass
@abstractmethod
def get_all(self):
pass
@abstractmethod
def update(self, memory_id, data):
pass
@abstractmethod
def delete(self, memory_id):
pass
@abstractmethod
def history(self, memory_id):
pass | --- +++ @@ -4,20 +4,60 @@ class MemoryBase(ABC):
@abstractmethod
def get(self, memory_id):
+ """
+ Retrieve a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to retrieve.
+
+ Returns:
+ dict: Retrieved memory.
+ """
pass
@abstractmethod
def get_all(self):
+ """
+ List all memories.
+
+ Returns:
+ list: List of all memories.
+ """
pass
@abstractmethod
def update(self, memory_id, data):
+ """
+ Update a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to update.
+ data (str): New content to update the memory with.
+
+ Returns:
+ dict: Success message indicating the memory was updated.
+ """
pass
@abstractmethod
def delete(self, memory_id):
+ """
+ Delete a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to delete.
+ """
pass
@abstractmethod
def history(self, memory_id):
- pass+ """
+ Get the history of changes for a memory by ID.
+
+ Args:
+ memory_id (str): ID of the memory to get history for.
+
+ Returns:
+ list: List of changes for the memory.
+ """
+ pass
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/memory/base.py |
Write Python docstrings for this snippet | import logging
import uuid
from datetime import datetime
import pytz
from .base import NeptuneBase
try:
from langchain_aws import NeptuneGraph
except ImportError:
raise ImportError("langchain_aws is not installed. Please install it using 'make install_all'.")
logger = logging.getLogger(__name__)
class MemoryGraph(NeptuneBase):
def __init__(self, config):
self.config = config
self.graph = None
endpoint = self.config.graph_store.config.endpoint
if endpoint and endpoint.startswith("neptune-db://"):
host = endpoint.replace("neptune-db://", "")
port = 8182
self.graph = NeptuneGraph(host, port)
if not self.graph:
raise ValueError("Unable to create a Neptune-DB client: missing 'endpoint' in config")
self.node_label = ":`__Entity__`" if self.config.graph_store.config.base_label else ""
self.embedding_model = NeptuneBase._create_embedding_model(self.config)
# Default to openai if no specific provider is configured
self.llm_provider = "openai"
if self.config.graph_store.llm:
self.llm_provider = self.config.graph_store.llm.provider
elif self.config.llm.provider:
self.llm_provider = self.config.llm.provider
# fetch the vector store as a provider
self.vector_store_provider = self.config.vector_store.provider
if self.config.graph_store.config.collection_name:
vector_store_collection_name = self.config.graph_store.config.collection_name
else:
vector_store_config = self.config.vector_store.config
if vector_store_config.collection_name:
vector_store_collection_name = vector_store_config.collection_name + "_neptune_vector_store"
else:
vector_store_collection_name = "mem0_neptune_vector_store"
self.config.vector_store.config.collection_name = vector_store_collection_name
self.vector_store = NeptuneBase._create_vector_store(self.vector_store_provider, self.config)
self.llm = NeptuneBase._create_llm(self.config, self.llm_provider)
self.user_id = None
# Use threshold from graph_store config, default to 0.7 for backward compatibility
self.threshold = self.config.graph_store.threshold if hasattr(self.config.graph_store, 'threshold') else 0.7
self.vector_store_limit=5
def _delete_entities_cypher(self, source, destination, relationship, user_id):
cypher = f"""
MATCH (n {self.node_label} {{name: $source_name, user_id: $user_id}})
-[r:{relationship}]->
(m {self.node_label} {{name: $dest_name, user_id: $user_id}})
DELETE r
RETURN
n.name AS source,
m.name AS target,
type(r) AS relationship
"""
params = {
"source_name": source,
"dest_name": destination,
"user_id": user_id,
}
logger.debug(f"_delete_entities\n query={cypher}")
return cypher, params
def _add_entities_by_source_cypher(
self,
source_node_list,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
):
destination_id = str(uuid.uuid4())
destination_payload = {
"name": destination,
"type": destination_type,
"user_id": user_id,
"created_at": datetime.now(pytz.timezone("US/Pacific")).isoformat(),
}
self.vector_store.insert(
vectors=[dest_embedding],
payloads=[destination_payload],
ids=[destination_id],
)
destination_label = self.node_label if self.node_label else f":`{destination_type}`"
destination_extra_set = f", destination:`{destination_type}`" if self.node_label else ""
cypher = f"""
MATCH (source {{user_id: $user_id}})
WHERE id(source) = $source_id
SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
MERGE (destination {destination_label} {{`~id`: $destination_id, name: $destination_name, user_id: $user_id}})
ON CREATE SET
destination.created = timestamp(),
destination.updated = timestamp(),
destination.mentions = 1
{destination_extra_set}
ON MATCH SET
destination.mentions = coalesce(destination.mentions, 0) + 1,
destination.updated = timestamp()
WITH source, destination
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp(),
r.updated = timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1,
r.updated = timestamp()
RETURN source.name AS source, type(r) AS relationship, destination.name AS target, id(destination) AS destination_id
"""
params = {
"source_id": source_node_list[0]["id(source_candidate)"],
"destination_id": destination_id,
"destination_name": destination,
"dest_embedding": dest_embedding,
"user_id": user_id,
}
logger.debug(
f"_add_entities:\n source_node_search_result={source_node_list[0]}\n query={cypher}"
)
return cypher, params
def _add_entities_by_destination_cypher(
self,
source,
source_embedding,
source_type,
destination_node_list,
relationship,
user_id,
):
source_id = str(uuid.uuid4())
source_payload = {
"name": source,
"type": source_type,
"user_id": user_id,
"created_at": datetime.now(pytz.timezone("US/Pacific")).isoformat(),
}
self.vector_store.insert(
vectors=[source_embedding],
payloads=[source_payload],
ids=[source_id],
)
source_label = self.node_label if self.node_label else f":`{source_type}`"
source_extra_set = f", source:`{source_type}`" if self.node_label else ""
cypher = f"""
MATCH (destination {{user_id: $user_id}})
WHERE id(destination) = $destination_id
SET
destination.mentions = coalesce(destination.mentions, 0) + 1,
destination.updated = timestamp()
WITH destination
MERGE (source {source_label} {{`~id`: $source_id, name: $source_name, user_id: $user_id}})
ON CREATE SET
source.created = timestamp(),
source.updated = timestamp(),
source.mentions = 1
{source_extra_set}
ON MATCH SET
source.mentions = coalesce(source.mentions, 0) + 1,
source.updated = timestamp()
WITH source, destination
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp(),
r.updated = timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1,
r.updated = timestamp()
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"destination_id": destination_node_list[0]["id(destination_candidate)"],
"source_id": source_id,
"source_name": source,
"source_embedding": source_embedding,
"user_id": user_id,
}
logger.debug(
f"_add_entities:\n destination_node_search_result={destination_node_list[0]}\n query={cypher}"
)
return cypher, params
def _add_relationship_entities_cypher(
self,
source_node_list,
destination_node_list,
relationship,
user_id,
):
cypher = f"""
MATCH (source {{user_id: $user_id}})
WHERE id(source) = $source_id
SET
source.mentions = coalesce(source.mentions, 0) + 1,
source.updated = timestamp()
WITH source
MATCH (destination {{user_id: $user_id}})
WHERE id(destination) = $destination_id
SET
destination.mentions = coalesce(destination.mentions) + 1,
destination.updated = timestamp()
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created_at = timestamp(),
r.updated_at = timestamp(),
r.mentions = 1
ON MATCH SET r.mentions = coalesce(r.mentions, 0) + 1
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"source_id": source_node_list[0]["id(source_candidate)"],
"destination_id": destination_node_list[0]["id(destination_candidate)"],
"user_id": user_id,
}
logger.debug(
f"_add_entities:\n destination_node_search_result={destination_node_list[0]}\n source_node_search_result={source_node_list[0]}\n query={cypher}"
)
return cypher, params
def _add_new_entities_cypher(
self,
source,
source_embedding,
source_type,
destination,
dest_embedding,
destination_type,
relationship,
user_id,
):
source_id = str(uuid.uuid4())
source_payload = {
"name": source,
"type": source_type,
"user_id": user_id,
"created_at": datetime.now(pytz.timezone("US/Pacific")).isoformat(),
}
destination_id = str(uuid.uuid4())
destination_payload = {
"name": destination,
"type": destination_type,
"user_id": user_id,
"created_at": datetime.now(pytz.timezone("US/Pacific")).isoformat(),
}
self.vector_store.insert(
vectors=[source_embedding, dest_embedding],
payloads=[source_payload, destination_payload],
ids=[source_id, destination_id],
)
source_label = self.node_label if self.node_label else f":`{source_type}`"
source_extra_set = f", source:`{source_type}`" if self.node_label else ""
destination_label = self.node_label if self.node_label else f":`{destination_type}`"
destination_extra_set = f", destination:`{destination_type}`" if self.node_label else ""
cypher = f"""
MERGE (n {source_label} {{name: $source_name, user_id: $user_id, `~id`: $source_id}})
ON CREATE SET n.created = timestamp(),
n.mentions = 1
{source_extra_set}
ON MATCH SET n.mentions = coalesce(n.mentions, 0) + 1
WITH n
MERGE (m {destination_label} {{name: $dest_name, user_id: $user_id, `~id`: $dest_id}})
ON CREATE SET m.created = timestamp(),
m.mentions = 1
{destination_extra_set}
ON MATCH SET m.mentions = coalesce(m.mentions, 0) + 1
WITH n, m
MERGE (n)-[rel:{relationship}]->(m)
ON CREATE SET rel.created = timestamp(), rel.mentions = 1
ON MATCH SET rel.mentions = coalesce(rel.mentions, 0) + 1
RETURN n.name AS source, type(rel) AS relationship, m.name AS target
"""
params = {
"source_id": source_id,
"dest_id": destination_id,
"source_name": source,
"dest_name": destination,
"source_embedding": source_embedding,
"dest_embedding": dest_embedding,
"user_id": user_id,
}
logger.debug(
f"_add_new_entities_cypher:\n query={cypher}"
)
return cypher, params
def _search_source_node_cypher(self, source_embedding, user_id, threshold):
source_nodes = self.vector_store.search(
query="",
vectors=source_embedding,
limit=self.vector_store_limit,
filters={"user_id": user_id},
)
ids = [n.id for n in filter(lambda s: s.score > threshold, source_nodes)]
cypher = f"""
MATCH (source_candidate {self.node_label})
WHERE source_candidate.user_id = $user_id AND id(source_candidate) IN $ids
RETURN id(source_candidate)
"""
params = {
"ids": ids,
"source_embedding": source_embedding,
"user_id": user_id,
"threshold": threshold,
}
logger.debug(f"_search_source_node\n query={cypher}")
return cypher, params
def _search_destination_node_cypher(self, destination_embedding, user_id, threshold):
destination_nodes = self.vector_store.search(
query="",
vectors=destination_embedding,
limit=self.vector_store_limit,
filters={"user_id": user_id},
)
ids = [n.id for n in filter(lambda d: d.score > threshold, destination_nodes)]
cypher = f"""
MATCH (destination_candidate {self.node_label})
WHERE destination_candidate.user_id = $user_id AND id(destination_candidate) IN $ids
RETURN id(destination_candidate)
"""
params = {
"ids": ids,
"destination_embedding": destination_embedding,
"user_id": user_id,
}
logger.debug(f"_search_destination_node\n query={cypher}")
return cypher, params
def _delete_all_cypher(self, filters):
# remove the vector store index
self.vector_store.reset()
# create a query that: deletes the nodes of the graph_store
cypher = f"""
MATCH (n {self.node_label} {{user_id: $user_id}})
DETACH DELETE n
"""
params = {"user_id": filters["user_id"]}
logger.debug(f"delete_all query={cypher}")
return cypher, params
def _get_all_cypher(self, filters, limit):
cypher = f"""
MATCH (n {self.node_label} {{user_id: $user_id}})-[r]->(m {self.node_label} {{user_id: $user_id}})
RETURN n.name AS source, type(r) AS relationship, m.name AS target
LIMIT $limit
"""
params = {"user_id": filters["user_id"], "limit": limit}
return cypher, params
def _search_graph_db_cypher(self, n_embedding, filters, limit):
# search vector store for applicable nodes using cosine similarity
search_nodes = self.vector_store.search(
query="",
vectors=n_embedding,
limit=self.vector_store_limit,
filters=filters,
)
ids = [n.id for n in search_nodes]
cypher_query = f"""
MATCH (n {self.node_label})-[r]->(m)
WHERE n.user_id = $user_id AND id(n) IN $n_ids
RETURN n.name AS source, id(n) AS source_id, type(r) AS relationship, id(r) AS relation_id, m.name AS destination, id(m) AS destination_id
UNION
MATCH (m)-[r]->(n {self.node_label})
RETURN m.name AS source, id(m) AS source_id, type(r) AS relationship, id(r) AS relation_id, n.name AS destination, id(n) AS destination_id
LIMIT $limit
"""
params = {
"n_ids": ids,
"user_id": filters["user_id"],
"limit": limit,
}
logger.debug(f"_search_graph_db\n query={cypher_query}")
return cypher_query, params | --- +++ @@ -14,6 +14,9 @@
class MemoryGraph(NeptuneBase):
def __init__(self, config):
+ """
+ Initialize the Neptune DB memory store.
+ """
self.config = config
@@ -58,6 +61,15 @@ self.vector_store_limit=5
def _delete_entities_cypher(self, source, destination, relationship, user_id):
+ """
+ Returns the OpenCypher query and parameters for deleting entities in the graph DB
+
+ :param source: source node
+ :param destination: destination node
+ :param relationship: relationship label
+ :param user_id: user_id to use
+ :return: str, dict
+ """
cypher = f"""
MATCH (n {self.node_label} {{name: $source_name, user_id: $user_id}})
@@ -86,6 +98,17 @@ relationship,
user_id,
):
+ """
+ Returns the OpenCypher query and parameters for adding entities in the graph DB
+
+ :param source_node_list: list of source nodes
+ :param destination: destination name
+ :param dest_embedding: destination embedding
+ :param destination_type: destination node label
+ :param relationship: relationship label
+ :param user_id: user id to use
+ :return: str, dict
+ """
destination_id = str(uuid.uuid4())
destination_payload = {
"name": destination,
@@ -150,6 +173,17 @@ relationship,
user_id,
):
+ """
+ Returns the OpenCypher query and parameters for adding entities in the graph DB
+
+ :param source: source node name
+ :param source_embedding: source node embedding
+ :param source_type: source node label
+ :param destination_node_list: list of dest nodes
+ :param relationship: relationship label
+ :param user_id: user id to use
+ :return: str, dict
+ """
source_id = str(uuid.uuid4())
source_payload = {
"name": source,
@@ -213,6 +247,15 @@ relationship,
user_id,
):
+ """
+ Returns the OpenCypher query and parameters for adding entities in the graph DB
+
+ :param source_node_list: list of source node ids
+ :param destination_node_list: list of dest node ids
+ :param relationship: relationship label
+ :param user_id: user id to use
+ :return: str, dict
+ """
cypher = f"""
MATCH (source {{user_id: $user_id}})
@@ -255,6 +298,19 @@ relationship,
user_id,
):
+ """
+ Returns the OpenCypher query and parameters for adding entities in the graph DB
+
+ :param source: source node name
+ :param source_embedding: source node embedding
+ :param source_type: source node label
+ :param destination: destination name
+ :param dest_embedding: destination embedding
+ :param destination_type: destination node label
+ :param relationship: relationship label
+ :param user_id: user id to use
+ :return: str, dict
+ """
source_id = str(uuid.uuid4())
source_payload = {
"name": source,
@@ -313,6 +369,14 @@ return cypher, params
def _search_source_node_cypher(self, source_embedding, user_id, threshold):
+ """
+ Returns the OpenCypher query and parameters to search for source nodes
+
+ :param source_embedding: source vector
+ :param user_id: user_id to use
+ :param threshold: the threshold for similarity
+ :return: str, dict
+ """
source_nodes = self.vector_store.search(
query="",
@@ -339,6 +403,14 @@ return cypher, params
def _search_destination_node_cypher(self, destination_embedding, user_id, threshold):
+ """
+ Returns the OpenCypher query and parameters to search for destination nodes
+
+ :param source_embedding: source vector
+ :param user_id: user_id to use
+ :param threshold: the threshold for similarity
+ :return: str, dict
+ """
destination_nodes = self.vector_store.search(
query="",
vectors=destination_embedding,
@@ -364,6 +436,12 @@ return cypher, params
def _delete_all_cypher(self, filters):
+ """
+ Returns the OpenCypher query and parameters to delete all edges/nodes in the memory store
+
+ :param filters: search filters
+ :return: str, dict
+ """
# remove the vector store index
self.vector_store.reset()
@@ -379,6 +457,13 @@ return cypher, params
def _get_all_cypher(self, filters, limit):
+ """
+ Returns the OpenCypher query and parameters to get all edges/nodes in the memory store
+
+ :param filters: search filters
+ :param limit: return limit
+ :return: str, dict
+ """
cypher = f"""
MATCH (n {self.node_label} {{user_id: $user_id}})-[r]->(m {self.node_label} {{user_id: $user_id}})
@@ -389,6 +474,14 @@ return cypher, params
def _search_graph_db_cypher(self, n_embedding, filters, limit):
+ """
+ Returns the OpenCypher query and parameters to search for similar nodes in the memory store
+
+ :param n_embedding: node vector
+ :param filters: search filters
+ :param limit: return limit
+ :return: str, dict
+ """
# search vector store for applicable nodes using cosine similarity
search_nodes = self.vector_store.search(
@@ -416,4 +509,4 @@ }
logger.debug(f"_search_graph_db\n query={cypher_query}")
- return cypher_query, params+ return cypher_query, params
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/graphs/neptune/neptunedb.py |
Add minimal docstrings for each function | import json
from typing import Dict, List, Optional
try:
import litellm
except ImportError:
raise ImportError("The 'litellm' library is required. Please install it using 'pip install litellm'.")
from mem0.configs.llms.base import BaseLlmConfig
from mem0.llms.base import LLMBase
from mem0.memory.utils import extract_json
class LiteLLM(LLMBase):
def __init__(self, config: Optional[BaseLlmConfig] = None):
super().__init__(config)
if not self.config.model:
self.config.model = "gpt-4.1-nano-2025-04-14"
def _parse_response(self, response, tools):
if tools:
processed_response = {
"content": response.choices[0].message.content,
"tool_calls": [],
}
if response.choices[0].message.tool_calls:
for tool_call in response.choices[0].message.tool_calls:
processed_response["tool_calls"].append(
{
"name": tool_call.function.name,
"arguments": json.loads(extract_json(tool_call.function.arguments)),
}
)
return processed_response
else:
return response.choices[0].message.content
def generate_response(
self,
messages: List[Dict[str, str]],
response_format=None,
tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
if not litellm.supports_function_calling(self.config.model):
raise ValueError(f"Model '{self.config.model}' in litellm does not support function calling.")
params = {
"model": self.config.model,
"messages": messages,
"temperature": self.config.temperature,
"max_tokens": self.config.max_tokens,
"top_p": self.config.top_p,
}
if response_format:
params["response_format"] = response_format
if tools: # TODO: Remove tools if no issues found with new memory addition logic
params["tools"] = tools
params["tool_choice"] = tool_choice
response = litellm.completion(**params)
return self._parse_response(response, tools) | --- +++ @@ -19,6 +19,16 @@ self.config.model = "gpt-4.1-nano-2025-04-14"
def _parse_response(self, response, tools):
+ """
+ Process the response based on whether tools are used or not.
+
+ Args:
+ response: The raw response from API.
+ tools: The list of tools provided in the request.
+
+ Returns:
+ str or dict: The processed response.
+ """
if tools:
processed_response = {
"content": response.choices[0].message.content,
@@ -45,6 +55,18 @@ tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
+ """
+ Generate a response based on the given messages using Litellm.
+
+ Args:
+ messages (list): List of message dicts containing 'role' and 'content'.
+ response_format (str or object, optional): Format of the response. Defaults to "text".
+ tools (list, optional): List of tools that the model can call. Defaults to None.
+ tool_choice (str, optional): Tool choice method. Defaults to "auto".
+
+ Returns:
+ str: The generated response.
+ """
if not litellm.supports_function_calling(self.config.model):
raise ValueError(f"Model '{self.config.model}' in litellm does not support function calling.")
@@ -62,4 +84,4 @@ params["tool_choice"] = tool_choice
response = litellm.completion(**params)
- return self._parse_response(response, tools)+ return self._parse_response(response, tools)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/llms/litellm.py |
Add detailed documentation for each class | import os
import re
import glob
import json
import logging
import torch
from nanochat.common import get_base_dir
from nanochat.gpt import GPT, GPTConfig
from nanochat.tokenizer import get_tokenizer
from nanochat.common import setup_default_logging
# Set up logging
setup_default_logging()
logger = logging.getLogger(__name__)
def log0(message):
if int(os.environ.get('RANK', 0)) == 0:
logger.info(message)
def _patch_missing_config_keys(model_config_kwargs):
# Old models were trained with full context (no sliding window)
if "window_pattern" not in model_config_kwargs:
model_config_kwargs["window_pattern"] = "L"
log0(f"Patching missing window_pattern in model config to 'L'")
def _patch_missing_keys(model_data, model_config):
n_layer = model_config.n_layer
# resid_lambdas defaults to 1.0 (identity scaling)
if "resid_lambdas" not in model_data:
model_data["resid_lambdas"] = torch.ones(n_layer)
log0(f"Patching missing resid_lambdas in model data to 1.0")
# x0_lambdas defaults to 0.0 (disabled)
if "x0_lambdas" not in model_data:
model_data["x0_lambdas"] = torch.zeros(n_layer)
log0(f"Patching missing x0_lambdas in model data to 0.0")
def save_checkpoint(checkpoint_dir, step, model_data, optimizer_data, meta_data, rank=0):
if rank == 0:
os.makedirs(checkpoint_dir, exist_ok=True)
# Save the model state parameters
model_path = os.path.join(checkpoint_dir, f"model_{step:06d}.pt")
torch.save(model_data, model_path)
logger.info(f"Saved model parameters to: {model_path}")
# Save the metadata dict as json
meta_path = os.path.join(checkpoint_dir, f"meta_{step:06d}.json")
with open(meta_path, "w", encoding="utf-8") as f:
json.dump(meta_data, f, indent=2)
logger.info(f"Saved metadata to: {meta_path}")
# Note that optimizer state is sharded across ranks, so each rank must save its own.
if optimizer_data is not None:
os.makedirs(checkpoint_dir, exist_ok=True)
optimizer_path = os.path.join(checkpoint_dir, f"optim_{step:06d}_rank{rank:d}.pt")
torch.save(optimizer_data, optimizer_path)
logger.info(f"Saved optimizer state to: {optimizer_path}")
def load_checkpoint(checkpoint_dir, step, device, load_optimizer=False, rank=0):
# Load the model state
model_path = os.path.join(checkpoint_dir, f"model_{step:06d}.pt")
model_data = torch.load(model_path, map_location=device)
# Load the optimizer state if requested
optimizer_data = None
if load_optimizer:
optimizer_path = os.path.join(checkpoint_dir, f"optim_{step:06d}_rank{rank:d}.pt")
optimizer_data = torch.load(optimizer_path, map_location=device)
# Load the metadata
meta_path = os.path.join(checkpoint_dir, f"meta_{step:06d}.json")
with open(meta_path, "r", encoding="utf-8") as f:
meta_data = json.load(f)
return model_data, optimizer_data, meta_data
def build_model(checkpoint_dir, step, device, phase):
assert phase in ["train", "eval"], f"Invalid phase: {phase}"
model_data, optimizer_data, meta_data = load_checkpoint(checkpoint_dir, step, device, load_optimizer=False)
if device.type in {"cpu", "mps"}:
# Convert bfloat16 tensors to float for CPU inference
model_data = {
k: v.float() if v.dtype == torch.bfloat16 else v
for k, v in model_data.items()
}
# Hack: fix torch compile issue, which prepends all keys with _orig_mod.
model_data = {k.removeprefix("_orig_mod."): v for k, v in model_data.items()}
model_config_kwargs = meta_data["model_config"]
_patch_missing_config_keys(model_config_kwargs)
log0(f"Building model with config: {model_config_kwargs}")
model_config = GPTConfig(**model_config_kwargs)
_patch_missing_keys(model_data, model_config)
with torch.device("meta"):
model = GPT(model_config)
# Load the model state
model.to_empty(device=device)
model.init_weights() # note: this is dumb, but we need to init the rotary embeddings. TODO: fix model re-init
model.load_state_dict(model_data, strict=True, assign=True)
# Put the model in the right training phase / mode
if phase == "eval":
model.eval()
else:
model.train()
# Load the Tokenizer
tokenizer = get_tokenizer()
# Sanity check: compatibility between model and tokenizer
assert tokenizer.get_vocab_size() == model_config_kwargs["vocab_size"], f"Tokenizer vocab size {tokenizer.get_vocab_size()} does not match model config vocab size {model_config_kwargs['vocab_size']}"
return model, tokenizer, meta_data
def find_largest_model(checkpoints_dir):
# attempt to guess the model tag: take the biggest model available
model_tags = [f for f in os.listdir(checkpoints_dir) if os.path.isdir(os.path.join(checkpoints_dir, f))]
if not model_tags:
raise FileNotFoundError(f"No checkpoints found in {checkpoints_dir}")
# 1) normally all model tags are of the form d<number>, try that first:
candidates = []
for model_tag in model_tags:
match = re.match(r"d(\d+)", model_tag)
if match:
model_depth = int(match.group(1))
candidates.append((model_depth, model_tag))
if candidates:
candidates.sort(key=lambda x: x[0], reverse=True)
return candidates[0][1]
# 2) if that failed, take the most recently updated model:
model_tags.sort(key=lambda x: os.path.getmtime(os.path.join(checkpoints_dir, x)), reverse=True)
return model_tags[0]
def find_last_step(checkpoint_dir):
# Look into checkpoint_dir and find model_<step>.pt with the highest step
checkpoint_files = glob.glob(os.path.join(checkpoint_dir, "model_*.pt"))
if not checkpoint_files:
raise FileNotFoundError(f"No checkpoints found in {checkpoint_dir}")
last_step = int(max(os.path.basename(f).split("_")[-1].split(".")[0] for f in checkpoint_files))
return last_step
# -----------------------------------------------------------------------------
# convenience functions that take into account nanochat's directory structure
def load_model_from_dir(checkpoints_dir, device, phase, model_tag=None, step=None):
if model_tag is None:
# guess the model tag by defaulting to the largest model
model_tag = find_largest_model(checkpoints_dir)
log0(f"No model tag provided, guessing model tag: {model_tag}")
checkpoint_dir = os.path.join(checkpoints_dir, model_tag)
if step is None:
# guess the step by defaulting to the last step
step = find_last_step(checkpoint_dir)
assert step is not None, f"No checkpoints found in {checkpoint_dir}"
# build the model
log0(f"Loading model from {checkpoint_dir} with step {step}")
model, tokenizer, meta_data = build_model(checkpoint_dir, step, device, phase)
return model, tokenizer, meta_data
def load_model(source, *args, **kwargs):
model_dir = {
"base": "base_checkpoints",
"sft": "chatsft_checkpoints",
"rl": "chatrl_checkpoints",
}[source]
base_dir = get_base_dir()
checkpoints_dir = os.path.join(base_dir, model_dir)
return load_model_from_dir(checkpoints_dir, *args, **kwargs)
def load_optimizer_state(source, device, rank, model_tag=None, step=None):
model_dir = {
"base": "base_checkpoints",
"sft": "chatsft_checkpoints",
"rl": "chatrl_checkpoints",
}[source]
base_dir = get_base_dir()
checkpoints_dir = os.path.join(base_dir, model_dir)
if model_tag is None:
model_tag = find_largest_model(checkpoints_dir)
checkpoint_dir = os.path.join(checkpoints_dir, model_tag)
if step is None:
step = find_last_step(checkpoint_dir)
optimizer_path = os.path.join(checkpoint_dir, f"optim_{step:06d}_rank{rank:d}.pt")
if not os.path.exists(optimizer_path):
log0(f"Optimizer checkpoint not found: {optimizer_path}")
return None
log0(f"Loading optimizer state from {optimizer_path}")
optimizer_data = torch.load(optimizer_path, map_location=device)
return optimizer_data | --- +++ @@ -1,3 +1,6 @@+"""
+Utilities for saving and loading model/optim/state checkpoints.
+"""
import os
import re
import glob
@@ -18,12 +21,14 @@ logger.info(message)
def _patch_missing_config_keys(model_config_kwargs):
+ """Add default values for new config keys missing in old checkpoints."""
# Old models were trained with full context (no sliding window)
if "window_pattern" not in model_config_kwargs:
model_config_kwargs["window_pattern"] = "L"
log0(f"Patching missing window_pattern in model config to 'L'")
def _patch_missing_keys(model_data, model_config):
+ """Add default values for new parameters that may be missing in old checkpoints."""
n_layer = model_config.n_layer
# resid_lambdas defaults to 1.0 (identity scaling)
if "resid_lambdas" not in model_data:
@@ -70,6 +75,13 @@
def build_model(checkpoint_dir, step, device, phase):
+ """
+ A bunch of repetitive code to build a model from a given checkpoint.
+ Returns:
+ - base model - uncompiled, not wrapped in DDP
+ - tokenizer
+ - meta data saved during base model training
+ """
assert phase in ["train", "eval"], f"Invalid phase: {phase}"
model_data, optimizer_data, meta_data = load_checkpoint(checkpoint_dir, step, device, load_optimizer=False)
if device.type in {"cpu", "mps"}:
@@ -160,6 +172,7 @@ return load_model_from_dir(checkpoints_dir, *args, **kwargs)
def load_optimizer_state(source, device, rank, model_tag=None, step=None):
+ """Load just the optimizer shard for a given rank, without re-loading the model."""
model_dir = {
"base": "base_checkpoints",
"sft": "chatsft_checkpoints",
@@ -178,4 +191,4 @@ return None
log0(f"Loading optimizer state from {optimizer_path}")
optimizer_data = torch.load(optimizer_path, map_location=device)
- return optimizer_data+ return optimizer_data
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/checkpoint_manager.py |
Write beginner-friendly docstrings |
import torch
import pyarrow.parquet as pq
from nanochat.common import get_dist_info
from nanochat.dataset import list_parquet_files
def _document_batches(split, resume_state_dict, tokenizer_batch_size):
ddp, ddp_rank, ddp_local_rank, ddp_world_size = get_dist_info()
warn_on_legacy = ddp_rank == 0 and split == "train" # rank 0 on train split will warn on legacy
parquet_paths = list_parquet_files(warn_on_legacy=warn_on_legacy)
assert len(parquet_paths) != 0, "No dataset parquet files found, did you run dataset.py?"
parquet_paths = parquet_paths[:-1] if split == "train" else parquet_paths[-1:]
resume_pq_idx = resume_state_dict["pq_idx"] if resume_state_dict is not None else 0
resume_rg_idx = resume_state_dict["rg_idx"] if resume_state_dict is not None else None
resume_epoch = resume_state_dict.get("epoch", 1) if resume_state_dict is not None else 1
first_pass = True
pq_idx = resume_pq_idx
epoch = resume_epoch
while True: # iterate infinitely (multi-epoch)
pq_idx = resume_pq_idx if first_pass else 0
while pq_idx < len(parquet_paths):
filepath = parquet_paths[pq_idx]
pf = pq.ParquetFile(filepath)
# Start from resume point if resuming on same file, otherwise from DDP rank
if first_pass and (resume_rg_idx is not None) and (pq_idx == resume_pq_idx):
base_idx = resume_rg_idx // ddp_world_size
base_idx += 1 # advance by 1 so we don't repeat data after resuming
rg_idx = base_idx * ddp_world_size + ddp_rank
if rg_idx >= pf.num_row_groups:
pq_idx += 1
continue
resume_rg_idx = None # only do this once
else:
rg_idx = ddp_rank
while rg_idx < pf.num_row_groups:
rg = pf.read_row_group(rg_idx)
batch = rg.column('text').to_pylist()
for i in range(0, len(batch), tokenizer_batch_size):
yield batch[i:i+tokenizer_batch_size], (pq_idx, rg_idx, epoch)
rg_idx += ddp_world_size
pq_idx += 1
first_pass = False
epoch += 1
def tokenizing_distributed_data_loader_with_state_bos_bestfit(
tokenizer, B, T, split,
tokenizer_threads=4, tokenizer_batch_size=128,
device="cuda", resume_state_dict=None,
buffer_size=1000
):
assert split in ["train", "val"], "split must be 'train' or 'val'"
row_capacity = T + 1
batches = _document_batches(split, resume_state_dict, tokenizer_batch_size)
bos_token = tokenizer.get_bos_token_id()
doc_buffer = []
pq_idx, rg_idx, epoch = 0, 0, 1
def refill_buffer():
nonlocal pq_idx, rg_idx, epoch
doc_batch, (pq_idx, rg_idx, epoch) = next(batches)
token_lists = tokenizer.encode(doc_batch, prepend=bos_token, num_threads=tokenizer_threads)
for tokens in token_lists:
doc_buffer.append(tokens)
# Pre-allocate buffers once: layout is [inputs (B*T) | targets (B*T)]
# This gives us contiguous views and a single HtoD transfer
use_cuda = device == "cuda"
row_buffer = torch.empty((B, row_capacity), dtype=torch.long) # for building rows without creating Python lists
cpu_buffer = torch.empty(2 * B * T, dtype=torch.long, pin_memory=use_cuda) # staging area (CPU)
gpu_buffer = torch.empty(2 * B * T, dtype=torch.long, device=device) # on-device buffer
cpu_inputs = cpu_buffer[:B * T].view(B, T) # a few views into these buffers just for convenience
cpu_targets = cpu_buffer[B * T:].view(B, T)
inputs = gpu_buffer[:B * T].view(B, T)
targets = gpu_buffer[B * T:].view(B, T)
while True:
for row_idx in range(B):
pos = 0
while pos < row_capacity:
# Ensure buffer has documents
while len(doc_buffer) < buffer_size:
refill_buffer()
remaining = row_capacity - pos
# Find largest doc that fits entirely
best_idx = -1
best_len = 0
for i, doc in enumerate(doc_buffer):
doc_len = len(doc)
if doc_len <= remaining and doc_len > best_len:
best_idx = i
best_len = doc_len
if best_idx >= 0:
doc = doc_buffer.pop(best_idx)
doc_len = len(doc)
row_buffer[row_idx, pos:pos + doc_len] = torch.tensor(doc, dtype=torch.long)
pos += doc_len
else:
# No doc fits - crop shortest in buffer to fill remaining and minimize waste
shortest_idx = min(range(len(doc_buffer)), key=lambda i: len(doc_buffer[i]))
doc = doc_buffer.pop(shortest_idx)
row_buffer[row_idx, pos:pos + remaining] = torch.tensor(doc[:remaining], dtype=torch.long)
pos += remaining
# Copy to pinned CPU buffer, then single HtoD transfer
cpu_inputs.copy_(row_buffer[:, :-1])
cpu_targets.copy_(row_buffer[:, 1:])
state_dict = {"pq_idx": pq_idx, "rg_idx": rg_idx, "epoch": epoch}
# Single HtoD copy into persistent GPU buffer and yield
gpu_buffer.copy_(cpu_buffer, non_blocking=use_cuda)
yield inputs, targets, state_dict
def tokenizing_distributed_data_loader_bos_bestfit(*args, **kwargs):
for inputs, targets, state_dict in tokenizing_distributed_data_loader_with_state_bos_bestfit(*args, **kwargs):
yield inputs, targets | --- +++ @@ -1,3 +1,20 @@+"""
+Distributed dataloaders for pretraining.
+
+BOS-aligned bestfit:
+ - Every row starts with BOS token
+ - Documents packed using best-fit algorithm to minimize cropping
+ - When no document fits remaining space, crops a document to fill exactly
+ - 100% utilization (no padding), ~35% tokens cropped at T=2048
+
+Compared to the original tokenizing_distributed_data_loader:
+BOS-aligned loses ~35% of tokens to cropping, but ensures that
+there are fewer "confusing" tokens in the train/val batches as every token can
+now attend back to the BOS token and sees the full context of the document.
+
+Fallback to the original if you have very limited data AND long documents:
+https://github.com/karpathy/nanochat/blob/3c3a3d7/nanochat/dataloader.py#L78-L117
+"""
import torch
import pyarrow.parquet as pq
@@ -6,6 +23,13 @@ from nanochat.dataset import list_parquet_files
def _document_batches(split, resume_state_dict, tokenizer_batch_size):
+ """
+ Infinite iterator over document batches (list of text strings) from parquet files.
+
+ Handles DDP sharding and approximate resume. Each yield is (text_batch, (pq_idx, rg_idx, epoch))
+ where text_batch is a list of document strings, indices track position for resumption,
+ and epoch counts how many times we've cycled through the dataset (starts at 1).
+ """
ddp, ddp_rank, ddp_local_rank, ddp_world_size = get_dist_info()
warn_on_legacy = ddp_rank == 0 and split == "train" # rank 0 on train split will warn on legacy
@@ -53,6 +77,22 @@ device="cuda", resume_state_dict=None,
buffer_size=1000
):
+ """
+ BOS-aligned dataloader with Best-Fit Cropping.
+
+ Reduces token waste compared to simple greedy cropping by searching a buffer
+ for documents that fit well, while maintaining 100% utilization (no padding).
+
+ Algorithm for each row:
+ 1. From buffered docs, pick the LARGEST doc that fits entirely
+ 2. Repeat until no doc fits
+ 3. When nothing fits, crop a doc to fill remaining space exactly
+
+ Key properties:
+ - Every row starts with BOS
+ - 100% utilization (no padding, every token is trained on)
+ - Approximately 35% of all tokens are discarded due to cropping
+ """
assert split in ["train", "val"], "split must be 'train' or 'val'"
row_capacity = T + 1
@@ -121,5 +161,6 @@ yield inputs, targets, state_dict
def tokenizing_distributed_data_loader_bos_bestfit(*args, **kwargs):
+ """Helper that omits state_dict from yields."""
for inputs, targets, state_dict in tokenizing_distributed_data_loader_with_state_bos_bestfit(*args, **kwargs):
- yield inputs, targets+ yield inputs, targets
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/dataloader.py |
Add docstrings to meet PEP guidelines |
import os
import re
import logging
import urllib.request
import torch
import torch.distributed as dist
from filelock import FileLock
# The dtype used for compute (matmuls, activations). Master weights stay fp32 for optimizer precision.
# Linear layers cast their weights to this dtype in forward, replacing torch.amp.autocast.
# Override with NANOCHAT_DTYPE env var: "bfloat16", "float16", "float32"
_DTYPE_MAP = {"bfloat16": torch.bfloat16, "float16": torch.float16, "float32": torch.float32}
def _detect_compute_dtype():
env = os.environ.get("NANOCHAT_DTYPE")
if env is not None:
return _DTYPE_MAP[env], f"set via NANOCHAT_DTYPE={env}"
if torch.cuda.is_available():
# bf16 requires SM 80+ (Ampere: A100, A10, etc.)
# Older GPUs like V100 (SM 70) and T4 (SM 75) only have fp16 tensor cores
capability = torch.cuda.get_device_capability()
if capability >= (8, 0):
return torch.bfloat16, f"auto-detected: CUDA SM {capability[0]}{capability[1]} (bf16 supported)"
# fp16 training requires GradScaler (not yet implemented), so fall back to fp32.
# Users can still force fp16 via NANOCHAT_DTYPE=float16 if they know what they're doing.
return torch.float32, f"auto-detected: CUDA SM {capability[0]}{capability[1]} (pre-Ampere, bf16 not supported, using fp32)"
return torch.float32, "auto-detected: no CUDA (CPU/MPS)"
COMPUTE_DTYPE, COMPUTE_DTYPE_REASON = _detect_compute_dtype()
class ColoredFormatter(logging.Formatter):
# ANSI color codes
COLORS = {
'DEBUG': '\033[36m', # Cyan
'INFO': '\033[32m', # Green
'WARNING': '\033[33m', # Yellow
'ERROR': '\033[31m', # Red
'CRITICAL': '\033[35m', # Magenta
}
RESET = '\033[0m'
BOLD = '\033[1m'
def format(self, record):
# Add color to the level name
levelname = record.levelname
if levelname in self.COLORS:
record.levelname = f"{self.COLORS[levelname]}{self.BOLD}{levelname}{self.RESET}"
# Format the message
message = super().format(record)
# Add color to specific parts of the message
if levelname == 'INFO':
# Highlight numbers and percentages
message = re.sub(r'(\d+\.?\d*\s*(?:GB|MB|%|docs))', rf'{self.BOLD}\1{self.RESET}', message)
message = re.sub(r'(Shard \d+)', rf'{self.COLORS["INFO"]}{self.BOLD}\1{self.RESET}', message)
return message
def setup_default_logging():
handler = logging.StreamHandler()
handler.setFormatter(ColoredFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logging.basicConfig(
level=logging.INFO,
handlers=[handler]
)
setup_default_logging()
logger = logging.getLogger(__name__)
def get_base_dir():
# co-locate nanochat intermediates with other cached data in ~/.cache (by default)
if os.environ.get("NANOCHAT_BASE_DIR"):
nanochat_dir = os.environ.get("NANOCHAT_BASE_DIR")
else:
home_dir = os.path.expanduser("~")
cache_dir = os.path.join(home_dir, ".cache")
nanochat_dir = os.path.join(cache_dir, "nanochat")
os.makedirs(nanochat_dir, exist_ok=True)
return nanochat_dir
def download_file_with_lock(url, filename, postprocess_fn=None):
base_dir = get_base_dir()
file_path = os.path.join(base_dir, filename)
lock_path = file_path + ".lock"
if os.path.exists(file_path):
return file_path
with FileLock(lock_path):
# Only a single rank can acquire this lock
# All other ranks block until it is released
# Recheck after acquiring lock
if os.path.exists(file_path):
return file_path
# Download the content as bytes
print(f"Downloading {url}...")
with urllib.request.urlopen(url) as response:
content = response.read() # bytes
# Write to local file
with open(file_path, 'wb') as f:
f.write(content)
print(f"Downloaded to {file_path}")
# Run the postprocess function if provided
if postprocess_fn is not None:
postprocess_fn(file_path)
return file_path
def print0(s="",**kwargs):
ddp_rank = int(os.environ.get('RANK', 0))
if ddp_rank == 0:
print(s, **kwargs)
def print_banner():
# Cool DOS Rebel font ASCII banner made with https://manytools.org/hacker-tools/ascii-banner/
banner = """
█████ █████
░░███ ░░███
████████ ██████ ████████ ██████ ██████ ░███████ ██████ ███████
░░███░░███ ░░░░░███ ░░███░░███ ███░░███ ███░░███ ░███░░███ ░░░░░███░░░███░
░███ ░███ ███████ ░███ ░███ ░███ ░███░███ ░░░ ░███ ░███ ███████ ░███
░███ ░███ ███░░███ ░███ ░███ ░███ ░███░███ ███ ░███ ░███ ███░░███ ░███ ███
████ █████░░████████ ████ █████░░██████ ░░██████ ████ █████░░███████ ░░█████
░░░░ ░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░░░ ░░░░░
"""
print0(banner)
def is_ddp_requested() -> bool:
return all(k in os.environ for k in ("RANK", "LOCAL_RANK", "WORLD_SIZE"))
def is_ddp_initialized() -> bool:
return dist.is_available() and dist.is_initialized()
def get_dist_info():
if is_ddp_requested():
# We rely on torchrun's env to decide if we SHOULD init.
# (Initialization itself happens in compute init.)
assert all(var in os.environ for var in ['RANK', 'LOCAL_RANK', 'WORLD_SIZE'])
ddp_rank = int(os.environ['RANK'])
ddp_local_rank = int(os.environ['LOCAL_RANK'])
ddp_world_size = int(os.environ['WORLD_SIZE'])
return True, ddp_rank, ddp_local_rank, ddp_world_size
else:
return False, 0, 0, 1
def autodetect_device_type():
# prefer to use CUDA if available, otherwise use MPS, otherwise fallback on CPU
if torch.cuda.is_available():
device_type = "cuda"
elif torch.backends.mps.is_available():
device_type = "mps"
else:
device_type = "cpu"
print0(f"Autodetected device type: {device_type}")
return device_type
def compute_init(device_type="cuda"): # cuda|cpu|mps
assert device_type in ["cuda", "mps", "cpu"], "Invalid device type atm"
if device_type == "cuda":
assert torch.cuda.is_available(), "Your PyTorch installation is not configured for CUDA but device_type is 'cuda'"
if device_type == "mps":
assert torch.backends.mps.is_available(), "Your PyTorch installation is not configured for MPS but device_type is 'mps'"
# Reproducibility
# Note that we set the global seeds here, but most of the code uses explicit rng objects.
# The only place where global rng might be used is nn.Module initialization of the model weights.
torch.manual_seed(42)
if device_type == "cuda":
torch.cuda.manual_seed(42)
# skipping full reproducibility for now, possibly investigate slowdown later
# torch.use_deterministic_algorithms(True)
# Precision
if device_type == "cuda":
torch.set_float32_matmul_precision("high") # uses tf32 instead of fp32 for matmuls, see https://docs.pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
# Distributed setup: Distributed Data Parallel (DDP), optional, and requires CUDA
is_ddp_requested, ddp_rank, ddp_local_rank, ddp_world_size = get_dist_info()
if is_ddp_requested and device_type == "cuda":
device = torch.device("cuda", ddp_local_rank)
torch.cuda.set_device(device) # make "cuda" default to this device
dist.init_process_group(backend="nccl", device_id=device)
dist.barrier()
else:
device = torch.device(device_type) # mps|cpu
if ddp_rank == 0:
logger.info(f"Distributed world size: {ddp_world_size}")
return is_ddp_requested, ddp_rank, ddp_local_rank, ddp_world_size, device
def compute_cleanup():
if is_ddp_initialized():
dist.destroy_process_group()
class DummyWandb:
def __init__(self):
pass
def log(self, *args, **kwargs):
pass
def finish(self):
pass
# hardcoded BF16 peak flops for various GPUs
# inspired by torchtitan: https://github.com/pytorch/torchtitan/blob/main/torchtitan/tools/utils.py
# and PR: https://github.com/karpathy/nanochat/pull/147
def get_peak_flops(device_name: str) -> float:
name = device_name.lower()
# Table order matters: more specific patterns first.
_PEAK_FLOPS_TABLE = (
# NVIDIA Blackwell
(["gb200"], 2.5e15),
(["grace blackwell"], 2.5e15),
(["b200"], 2.25e15),
(["b100"], 1.8e15),
# NVIDIA Hopper
(["h200", "nvl"], 836e12),
(["h200", "pcie"], 836e12),
(["h200"], 989e12),
(["h100", "nvl"], 835e12),
(["h100", "pcie"], 756e12),
(["h100"], 989e12),
(["h800", "nvl"], 989e12),
(["h800"], 756e12),
# NVIDIA Ampere data center
(["a100"], 312e12),
(["a800"], 312e12),
(["a40"], 149.7e12),
(["a30"], 165e12),
# NVIDIA Ada data center
(["l40s"], 362e12),
(["l40-s"], 362e12),
(["l40 s"], 362e12),
(["l4"], 121e12),
# AMD CDNA accelerators
(["mi355"], 2.5e15),
(["mi325"], 1.3074e15),
(["mi300x"], 1.3074e15),
(["mi300a"], 980.6e12),
(["mi250x"], 383e12),
(["mi250"], 362.1e12),
# Consumer RTX
(["5090"], 209.5e12),
(["4090"], 165.2e12),
(["3090"], 71e12),
)
for patterns, flops in _PEAK_FLOPS_TABLE:
if all(p in name for p in patterns):
return flops
if "data center gpu max 1550" in name:
# Ponte Vecchio (PVC) - dynamic based on compute units
max_comp_units = torch.xpu.get_device_properties("xpu").max_compute_units
return 512 * max_comp_units * 1300 * 10**6
# Unknown GPU - return inf so MFU shows as 0% rather than a wrong guess
logger.warning(f"Peak flops undefined for: {device_name}, MFU will show as 0%")
return float('inf') | --- +++ @@ -1,3 +1,6 @@+"""
+Common utilities for nanochat.
+"""
import os
import re
@@ -28,6 +31,7 @@ COMPUTE_DTYPE, COMPUTE_DTYPE_REASON = _detect_compute_dtype()
class ColoredFormatter(logging.Formatter):
+ """Custom formatter that adds colors to log messages."""
# ANSI color codes
COLORS = {
'DEBUG': '\033[36m', # Cyan
@@ -75,6 +79,10 @@ return nanochat_dir
def download_file_with_lock(url, filename, postprocess_fn=None):
+ """
+ Downloads a file from a URL to a local path in the base directory.
+ Uses a lock file to prevent concurrent downloads among multiple ranks.
+ """
base_dir = get_base_dir()
file_path = os.path.join(base_dir, filename)
lock_path = file_path + ".lock"
@@ -126,9 +134,17 @@ print0(banner)
def is_ddp_requested() -> bool:
+ """
+ True if launched by torchrun (env present), even before init.
+ Used to decide whether we *should* initialize a PG.
+ """
return all(k in os.environ for k in ("RANK", "LOCAL_RANK", "WORLD_SIZE"))
def is_ddp_initialized() -> bool:
+ """
+ True if torch.distributed is available and the process group is initialized.
+ Used at cleanup to avoid destroying a non-existent PG.
+ """
return dist.is_available() and dist.is_initialized()
def get_dist_info():
@@ -155,6 +171,7 @@ return device_type
def compute_init(device_type="cuda"): # cuda|cpu|mps
+ """Basic initialization that we keep doing over and over, so make common."""
assert device_type in ["cuda", "mps", "cpu"], "Invalid device type atm"
if device_type == "cuda":
@@ -191,10 +208,12 @@ return is_ddp_requested, ddp_rank, ddp_local_rank, ddp_world_size, device
def compute_cleanup():
+ """Companion function to compute_init, to clean things up before script exit"""
if is_ddp_initialized():
dist.destroy_process_group()
class DummyWandb:
+ """Useful if we wish to not use wandb but have all the same signatures"""
def __init__(self):
pass
def log(self, *args, **kwargs):
@@ -256,4 +275,4 @@
# Unknown GPU - return inf so MFU shows as 0% rather than a wrong guess
logger.warning(f"Peak flops undefined for: {device_name}, MFU will show as 0%")
- return float('inf')+ return float('inf')
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/common.py |
Write reusable docstrings | import logging
import os
from typing import Any, Dict, List, Optional
from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse, RedirectResponse
from pydantic import BaseModel, Field
from mem0 import Memory
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
# Load environment variables
load_dotenv()
POSTGRES_HOST = os.environ.get("POSTGRES_HOST", "postgres")
POSTGRES_PORT = os.environ.get("POSTGRES_PORT", "5432")
POSTGRES_DB = os.environ.get("POSTGRES_DB", "postgres")
POSTGRES_USER = os.environ.get("POSTGRES_USER", "postgres")
POSTGRES_PASSWORD = os.environ.get("POSTGRES_PASSWORD", "postgres")
POSTGRES_COLLECTION_NAME = os.environ.get("POSTGRES_COLLECTION_NAME", "memories")
NEO4J_URI = os.environ.get("NEO4J_URI", "bolt://neo4j:7687")
NEO4J_USERNAME = os.environ.get("NEO4J_USERNAME", "neo4j")
NEO4J_PASSWORD = os.environ.get("NEO4J_PASSWORD", "mem0graph")
MEMGRAPH_URI = os.environ.get("MEMGRAPH_URI", "bolt://localhost:7687")
MEMGRAPH_USERNAME = os.environ.get("MEMGRAPH_USERNAME", "memgraph")
MEMGRAPH_PASSWORD = os.environ.get("MEMGRAPH_PASSWORD", "mem0graph")
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
HISTORY_DB_PATH = os.environ.get("HISTORY_DB_PATH", "/app/history/history.db")
DEFAULT_CONFIG = {
"version": "v1.1",
"vector_store": {
"provider": "pgvector",
"config": {
"host": POSTGRES_HOST,
"port": int(POSTGRES_PORT),
"dbname": POSTGRES_DB,
"user": POSTGRES_USER,
"password": POSTGRES_PASSWORD,
"collection_name": POSTGRES_COLLECTION_NAME,
},
},
"graph_store": {
"provider": "neo4j",
"config": {"url": NEO4J_URI, "username": NEO4J_USERNAME, "password": NEO4J_PASSWORD},
},
"llm": {"provider": "openai", "config": {"api_key": OPENAI_API_KEY, "temperature": 0.2, "model": "gpt-4.1-nano-2025-04-14"}},
"embedder": {"provider": "openai", "config": {"api_key": OPENAI_API_KEY, "model": "text-embedding-3-small"}},
"history_db_path": HISTORY_DB_PATH,
}
MEMORY_INSTANCE = Memory.from_config(DEFAULT_CONFIG)
app = FastAPI(
title="Mem0 REST APIs",
description="A REST API for managing and searching memories for your AI Agents and Apps.",
version="1.0.0",
)
class Message(BaseModel):
role: str = Field(..., description="Role of the message (user or assistant).")
content: str = Field(..., description="Message content.")
class MemoryCreate(BaseModel):
messages: List[Message] = Field(..., description="List of messages to store.")
user_id: Optional[str] = None
agent_id: Optional[str] = None
run_id: Optional[str] = None
metadata: Optional[Dict[str, Any]] = None
class SearchRequest(BaseModel):
query: str = Field(..., description="Search query.")
user_id: Optional[str] = None
run_id: Optional[str] = None
agent_id: Optional[str] = None
filters: Optional[Dict[str, Any]] = None
@app.post("/configure", summary="Configure Mem0")
def set_config(config: Dict[str, Any]):
global MEMORY_INSTANCE
MEMORY_INSTANCE = Memory.from_config(config)
return {"message": "Configuration set successfully"}
@app.post("/memories", summary="Create memories")
def add_memory(memory_create: MemoryCreate):
if not any([memory_create.user_id, memory_create.agent_id, memory_create.run_id]):
raise HTTPException(status_code=400, detail="At least one identifier (user_id, agent_id, run_id) is required.")
params = {k: v for k, v in memory_create.model_dump().items() if v is not None and k != "messages"}
try:
response = MEMORY_INSTANCE.add(messages=[m.model_dump() for m in memory_create.messages], **params)
return JSONResponse(content=response)
except Exception as e:
logging.exception("Error in add_memory:") # This will log the full traceback
raise HTTPException(status_code=500, detail=str(e))
@app.get("/memories", summary="Get memories")
def get_all_memories(
user_id: Optional[str] = None,
run_id: Optional[str] = None,
agent_id: Optional[str] = None,
):
if not any([user_id, run_id, agent_id]):
raise HTTPException(status_code=400, detail="At least one identifier is required.")
try:
params = {
k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
}
return MEMORY_INSTANCE.get_all(**params)
except Exception as e:
logging.exception("Error in get_all_memories:")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/memories/{memory_id}", summary="Get a memory")
def get_memory(memory_id: str):
try:
return MEMORY_INSTANCE.get(memory_id)
except Exception as e:
logging.exception("Error in get_memory:")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/search", summary="Search memories")
def search_memories(search_req: SearchRequest):
try:
params = {k: v for k, v in search_req.model_dump().items() if v is not None and k != "query"}
return MEMORY_INSTANCE.search(query=search_req.query, **params)
except Exception as e:
logging.exception("Error in search_memories:")
raise HTTPException(status_code=500, detail=str(e))
@app.put("/memories/{memory_id}", summary="Update a memory")
def update_memory(memory_id: str, updated_memory: Dict[str, Any]):
try:
return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory)
except Exception as e:
logging.exception("Error in update_memory:")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/memories/{memory_id}/history", summary="Get memory history")
def memory_history(memory_id: str):
try:
return MEMORY_INSTANCE.history(memory_id=memory_id)
except Exception as e:
logging.exception("Error in memory_history:")
raise HTTPException(status_code=500, detail=str(e))
@app.delete("/memories/{memory_id}", summary="Delete a memory")
def delete_memory(memory_id: str):
try:
MEMORY_INSTANCE.delete(memory_id=memory_id)
return {"message": "Memory deleted successfully"}
except Exception as e:
logging.exception("Error in delete_memory:")
raise HTTPException(status_code=500, detail=str(e))
@app.delete("/memories", summary="Delete all memories")
def delete_all_memories(
user_id: Optional[str] = None,
run_id: Optional[str] = None,
agent_id: Optional[str] = None,
):
if not any([user_id, run_id, agent_id]):
raise HTTPException(status_code=400, detail="At least one identifier is required.")
try:
params = {
k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
}
MEMORY_INSTANCE.delete_all(**params)
return {"message": "All relevant memories deleted"}
except Exception as e:
logging.exception("Error in delete_all_memories:")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/reset", summary="Reset all memories")
def reset_memory():
try:
MEMORY_INSTANCE.reset()
return {"message": "All memories reset"}
except Exception as e:
logging.exception("Error in reset_memory:")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/", summary="Redirect to the OpenAPI documentation", include_in_schema=False)
def home():
return RedirectResponse(url="/docs") | --- +++ @@ -88,6 +88,7 @@
@app.post("/configure", summary="Configure Mem0")
def set_config(config: Dict[str, Any]):
+ """Set memory configuration."""
global MEMORY_INSTANCE
MEMORY_INSTANCE = Memory.from_config(config)
return {"message": "Configuration set successfully"}
@@ -95,6 +96,7 @@
@app.post("/memories", summary="Create memories")
def add_memory(memory_create: MemoryCreate):
+ """Store new memories."""
if not any([memory_create.user_id, memory_create.agent_id, memory_create.run_id]):
raise HTTPException(status_code=400, detail="At least one identifier (user_id, agent_id, run_id) is required.")
@@ -113,6 +115,7 @@ run_id: Optional[str] = None,
agent_id: Optional[str] = None,
):
+ """Retrieve stored memories."""
if not any([user_id, run_id, agent_id]):
raise HTTPException(status_code=400, detail="At least one identifier is required.")
try:
@@ -127,6 +130,7 @@
@app.get("/memories/{memory_id}", summary="Get a memory")
def get_memory(memory_id: str):
+ """Retrieve a specific memory by ID."""
try:
return MEMORY_INSTANCE.get(memory_id)
except Exception as e:
@@ -136,6 +140,7 @@
@app.post("/search", summary="Search memories")
def search_memories(search_req: SearchRequest):
+ """Search for memories based on a query."""
try:
params = {k: v for k, v in search_req.model_dump().items() if v is not None and k != "query"}
return MEMORY_INSTANCE.search(query=search_req.query, **params)
@@ -146,6 +151,15 @@
@app.put("/memories/{memory_id}", summary="Update a memory")
def update_memory(memory_id: str, updated_memory: Dict[str, Any]):
+ """Update an existing memory with new content.
+
+ Args:
+ memory_id (str): ID of the memory to update
+ updated_memory (str): New content to update the memory with
+
+ Returns:
+ dict: Success message indicating the memory was updated
+ """
try:
return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory)
except Exception as e:
@@ -155,6 +169,7 @@
@app.get("/memories/{memory_id}/history", summary="Get memory history")
def memory_history(memory_id: str):
+ """Retrieve memory history."""
try:
return MEMORY_INSTANCE.history(memory_id=memory_id)
except Exception as e:
@@ -164,6 +179,7 @@
@app.delete("/memories/{memory_id}", summary="Delete a memory")
def delete_memory(memory_id: str):
+ """Delete a specific memory by ID."""
try:
MEMORY_INSTANCE.delete(memory_id=memory_id)
return {"message": "Memory deleted successfully"}
@@ -178,6 +194,7 @@ run_id: Optional[str] = None,
agent_id: Optional[str] = None,
):
+ """Delete all memories for a given identifier."""
if not any([user_id, run_id, agent_id]):
raise HTTPException(status_code=400, detail="At least one identifier is required.")
try:
@@ -193,6 +210,7 @@
@app.post("/reset", summary="Reset all memories")
def reset_memory():
+ """Completely reset stored memories."""
try:
MEMORY_INSTANCE.reset()
return {"message": "All memories reset"}
@@ -203,4 +221,5 @@
@app.get("/", summary="Redirect to the OpenAPI documentation", include_in_schema=False)
def home():
- return RedirectResponse(url="/docs")+ """Redirect to the OpenAPI documentation."""
+ return RedirectResponse(url="/docs")
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/server/main.py |
Generate consistent docstrings | #!/usr/bin/env python3
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
DOCS_BASE = "https://docs.mem0.ai"
SEARCH_ENDPOINT = f"{DOCS_BASE}/api/search"
LLMS_INDEX = f"{DOCS_BASE}/llms.txt"
# Known documentation sections for targeted retrieval
SECTION_MAP = {
"platform": [
"/platform/overview",
"/platform/quickstart",
"/platform/features",
"/platform/features/graph-memory",
"/platform/features/selective-memory",
"/platform/features/custom-categories",
"/platform/features/v2-memory-filters",
"/platform/features/async-client",
"/platform/features/webhooks",
"/platform/features/multimodal",
],
"api": [
"/api-reference/memory/add-memories",
"/api-reference/memory/v2-search-memories",
"/api-reference/memory/v2-get-memories",
"/api-reference/memory/get-memory",
"/api-reference/memory/update-memory",
"/api-reference/memory/delete-memory",
],
"open-source": [
"/open-source/overview",
"/open-source/python-quickstart",
"/open-source/node-quickstart",
"/open-source/features",
"/open-source/features/graph-memory",
"/open-source/features/rest-api",
"/open-source/configure-components",
],
"openmemory": [
"/openmemory/overview",
"/openmemory/quickstart",
],
"sdks": [
"/sdks/python",
"/sdks/js",
],
"integrations": [
"/integrations",
],
}
def fetch_url(url: str) -> str:
req = urllib.request.Request(url, headers={"User-Agent": "Mem0DocSearchAgent/1.0"})
try:
with urllib.request.urlopen(req, timeout=15) as resp:
return resp.read().decode("utf-8")
except urllib.error.HTTPError as e:
return f"HTTP Error {e.code}: {e.reason}"
except urllib.error.URLError as e:
return f"URL Error: {e.reason}"
def search_docs(query: str, section: str | None = None) -> dict:
# Try Mintlify search API first
params = urllib.parse.urlencode({"query": query})
search_url = f"{SEARCH_ENDPOINT}?{params}"
try:
result = fetch_url(search_url)
data = json.loads(result)
if isinstance(data, dict) and data.get("results"):
results = data["results"]
if section and section in SECTION_MAP:
section_paths = SECTION_MAP[section]
results = [r for r in results if any(r.get("url", "").startswith(p) for p in section_paths)]
return {"source": "mintlify_search", "results": results}
except (json.JSONDecodeError, Exception):
pass
# Fallback: search llms.txt index for matching URLs
index_content = fetch_url(LLMS_INDEX)
query_lower = query.lower()
matching_urls = []
for line in index_content.splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
if query_lower in line.lower():
matching_urls.append(line)
if section and section in SECTION_MAP:
section_paths = SECTION_MAP[section]
matching_urls = [u for u in matching_urls if any(p in u for p in section_paths)]
return {
"source": "llms_txt_index",
"query": query,
"matching_urls": matching_urls[:20],
"suggestion": "Fetch specific URLs for detailed content",
}
def fetch_page(page_path: str) -> dict:
url = f"{DOCS_BASE}{page_path}" if page_path.startswith("/") else page_path
content = fetch_url(url)
return {"url": url, "content": content[:10000], "truncated": len(content) > 10000}
def get_index() -> dict:
content = fetch_url(LLMS_INDEX)
urls = [line.strip() for line in content.splitlines() if line.strip() and not line.startswith("#")]
return {"total_pages": len(urls), "urls": urls, "sections": list(SECTION_MAP.keys())}
def list_section(section: str) -> dict:
if section not in SECTION_MAP:
return {"error": f"Unknown section: {section}", "available": list(SECTION_MAP.keys())}
return {
"section": section,
"pages": [f"{DOCS_BASE}{p}" for p in SECTION_MAP[section]],
}
def main():
parser = argparse.ArgumentParser(description="Search Mem0 documentation on demand")
parser.add_argument("--query", help="Search query for documentation")
parser.add_argument("--page", help="Fetch a specific page path (e.g., /platform/features/graph-memory)")
parser.add_argument("--index", action="store_true", help="Show full documentation index")
parser.add_argument("--section", help="Filter by section or list section pages")
parser.add_argument("--json", action="store_true", help="Output as JSON")
args = parser.parse_args()
if args.index:
result = get_index()
elif args.section and not args.query:
result = list_section(args.section)
elif args.page:
result = fetch_page(args.page)
elif args.query:
result = search_docs(args.query, section=args.section)
else:
parser.print_help()
sys.exit(1)
if args.json:
print(json.dumps(result, indent=2))
else:
if isinstance(result, dict):
if "results" in result:
print(f"Source: {result.get('source', 'unknown')}")
for r in result["results"]:
print(f" - {r.get('title', 'N/A')}: {r.get('url', 'N/A')}")
if r.get("description"):
print(f" {r['description'][:200]}")
elif "matching_urls" in result:
print(f"Source: {result['source']}")
print(f"Query: {result['query']}")
for url in result["matching_urls"]:
print(f" - {url}")
if result.get("suggestion"):
print(f"\n{result['suggestion']}")
elif "urls" in result:
print(f"Total documentation pages: {result['total_pages']}")
print(f"Sections: {', '.join(result['sections'])}")
for url in result["urls"][:30]:
print(f" - {url}")
if result["total_pages"] > 30:
print(f" ... and {result['total_pages'] - 30} more")
elif "pages" in result:
print(f"Section: {result['section']}")
for page in result["pages"]:
print(f" - {page}")
elif "content" in result:
print(f"URL: {result['url']}")
if result.get("truncated"):
print("[Content truncated to 10000 chars]")
print(result["content"])
elif "error" in result:
print(f"Error: {result['error']}")
if result.get("available"):
print(f"Available sections: {', '.join(result['available'])}")
else:
print(json.dumps(result, indent=2))
if __name__ == "__main__":
main() | --- +++ @@ -1,4 +1,24 @@ #!/usr/bin/env python3
+"""
+Mem0 Documentation Search Agent (Mintlify-based)
+On-demand search tool for querying Mem0 documentation without storing content locally.
+
+This tool leverages Mintlify's documentation structure to perform just-in-time
+retrieval of technical information from docs.mem0.ai.
+
+Usage:
+ python mem0_doc_search.py --query "how to add graph memory"
+ python mem0_doc_search.py --query "filter syntax for categories"
+ python mem0_doc_search.py --page "/platform/features/graph-memory"
+ python mem0_doc_search.py --index
+ python mem0_doc_search.py --query "webhook events" --section platform
+
+Purpose:
+ - Avoid bloating local context with full documentation
+ - Enable just-in-time retrieval of technical details
+ - Query specific documentation pages on demand
+ - Search across the full Mem0 documentation site
+"""
import argparse
import json
@@ -57,6 +77,7 @@
def fetch_url(url: str) -> str:
+ """Fetch content from a URL."""
req = urllib.request.Request(url, headers={"User-Agent": "Mem0DocSearchAgent/1.0"})
try:
with urllib.request.urlopen(req, timeout=15) as resp:
@@ -68,6 +89,10 @@
def search_docs(query: str, section: str | None = None) -> dict:
+ """
+ Search Mem0 documentation using Mintlify's search API.
+ Falls back to the llms.txt index for keyword matching if the API is unavailable.
+ """
# Try Mintlify search API first
params = urllib.parse.urlencode({"query": query})
search_url = f"{SEARCH_ENDPOINT}?{params}"
@@ -109,18 +134,21 @@
def fetch_page(page_path: str) -> dict:
+ """Fetch a specific documentation page."""
url = f"{DOCS_BASE}{page_path}" if page_path.startswith("/") else page_path
content = fetch_url(url)
return {"url": url, "content": content[:10000], "truncated": len(content) > 10000}
def get_index() -> dict:
+ """Fetch the full documentation index from llms.txt."""
content = fetch_url(LLMS_INDEX)
urls = [line.strip() for line in content.splitlines() if line.strip() and not line.startswith("#")]
return {"total_pages": len(urls), "urls": urls, "sections": list(SECTION_MAP.keys())}
def list_section(section: str) -> dict:
+ """List all known pages in a documentation section."""
if section not in SECTION_MAP:
return {"error": f"Unknown section: {section}", "available": list(SECTION_MAP.keys())}
return {
@@ -193,4 +221,4 @@
if __name__ == "__main__":
- main()+ main()
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/skills/mem0/scripts/mem0_doc_search.py |
Generate docstrings for exported functions | import logging
from typing import Dict, List, Optional
from pydantic import BaseModel
try:
from langchain_community.vectorstores import VectorStore
except ImportError:
raise ImportError(
"The 'langchain_community' library is required. Please install it using 'pip install langchain_community'."
)
from mem0.vector_stores.base import VectorStoreBase
logger = logging.getLogger(__name__)
class OutputData(BaseModel):
id: Optional[str] # memory id
score: Optional[float] # distance
payload: Optional[Dict] # metadata
class Langchain(VectorStoreBase):
def __init__(self, client: VectorStore, collection_name: str = "mem0"):
self.client = client
self.collection_name = collection_name
def _parse_output(self, data: Dict) -> List[OutputData]:
# Check if input is a list of Document objects
if isinstance(data, list) and all(hasattr(doc, "metadata") for doc in data if hasattr(doc, "__dict__")):
result = []
for doc in data:
entry = OutputData(
id=getattr(doc, "id", None),
score=None, # Document objects typically don't include scores
payload=getattr(doc, "metadata", {}),
)
result.append(entry)
return result
# Original format handling
keys = ["ids", "distances", "metadatas"]
values = []
for key in keys:
value = data.get(key, [])
if isinstance(value, list) and value and isinstance(value[0], list):
value = value[0]
values.append(value)
ids, distances, metadatas = values
max_length = max(len(v) for v in values if isinstance(v, list) and v is not None)
result = []
for i in range(max_length):
entry = OutputData(
id=ids[i] if isinstance(ids, list) and ids and i < len(ids) else None,
score=(distances[i] if isinstance(distances, list) and distances and i < len(distances) else None),
payload=(metadatas[i] if isinstance(metadatas, list) and metadatas and i < len(metadatas) else None),
)
result.append(entry)
return result
def create_col(self, name, vector_size=None, distance=None):
self.collection_name = name
return self.client
def insert(
self, vectors: List[List[float]], payloads: Optional[List[Dict]] = None, ids: Optional[List[str]] = None
):
# Check if client has add_embeddings method
if hasattr(self.client, "add_embeddings"):
# Some LangChain vectorstores have a direct add_embeddings method
self.client.add_embeddings(embeddings=vectors, metadatas=payloads, ids=ids)
else:
# Fallback to add_texts method
texts = [payload.get("data", "") for payload in payloads] if payloads else [""] * len(vectors)
self.client.add_texts(texts=texts, metadatas=payloads, ids=ids)
def search(self, query: str, vectors: List[List[float]], limit: int = 5, filters: Optional[Dict] = None):
# For each vector, perform a similarity search
if filters:
results = self.client.similarity_search_by_vector(embedding=vectors, k=limit, filter=filters)
else:
results = self.client.similarity_search_by_vector(embedding=vectors, k=limit)
final_results = self._parse_output(results)
return final_results
def delete(self, vector_id):
self.client.delete(ids=[vector_id])
def update(self, vector_id, vector=None, payload=None):
self.delete(vector_id)
self.insert(vector, payload, [vector_id])
def get(self, vector_id):
docs = self.client.get_by_ids([vector_id])
if docs and len(docs) > 0:
doc = docs[0]
return self._parse_output([doc])[0]
return None
def list_cols(self):
# LangChain doesn't have collections
return [self.collection_name]
def delete_col(self):
logger.warning("Deleting collection")
if hasattr(self.client, "delete_collection"):
self.client.delete_collection()
elif hasattr(self.client, "reset_collection"):
self.client.reset_collection()
else:
self.client.delete(ids=None)
def col_info(self):
return {"name": self.collection_name}
def list(self, filters=None, limit=None):
try:
if hasattr(self.client, "_collection") and hasattr(self.client._collection, "get"):
# Convert mem0 filters to Chroma where clause if needed
where_clause = None
if filters:
# Handle all filters, not just user_id
where_clause = filters
result = self.client._collection.get(where=where_clause, limit=limit)
# Convert the result to the expected format
if result and isinstance(result, dict):
return [self._parse_output(result)]
return []
except Exception as e:
logger.error(f"Error listing vectors from Chroma: {e}")
return []
def reset(self):
logger.warning(f"Resetting collection: {self.collection_name}")
self.delete_col() | --- +++ @@ -27,6 +27,15 @@ self.collection_name = collection_name
def _parse_output(self, data: Dict) -> List[OutputData]:
+ """
+ Parse the output data.
+
+ Args:
+ data (Dict): Output data or list of Document objects.
+
+ Returns:
+ List[OutputData]: Parsed output data.
+ """
# Check if input is a list of Document objects
if isinstance(data, list) and all(hasattr(doc, "metadata") for doc in data if hasattr(doc, "__dict__")):
result = []
@@ -70,6 +79,9 @@ def insert(
self, vectors: List[List[float]], payloads: Optional[List[Dict]] = None, ids: Optional[List[str]] = None
):
+ """
+ Insert vectors into the LangChain vectorstore.
+ """
# Check if client has add_embeddings method
if hasattr(self.client, "add_embeddings"):
# Some LangChain vectorstores have a direct add_embeddings method
@@ -80,6 +92,9 @@ self.client.add_texts(texts=texts, metadatas=payloads, ids=ids)
def search(self, query: str, vectors: List[List[float]], limit: int = 5, filters: Optional[Dict] = None):
+ """
+ Search for similar vectors in LangChain.
+ """
# For each vector, perform a similarity search
if filters:
results = self.client.similarity_search_by_vector(embedding=vectors, k=limit, filter=filters)
@@ -90,13 +105,22 @@ return final_results
def delete(self, vector_id):
+ """
+ Delete a vector by ID.
+ """
self.client.delete(ids=[vector_id])
def update(self, vector_id, vector=None, payload=None):
+ """
+ Update a vector and its payload.
+ """
self.delete(vector_id)
self.insert(vector, payload, [vector_id])
def get(self, vector_id):
+ """
+ Retrieve a vector by ID.
+ """
docs = self.client.get_by_ids([vector_id])
if docs and len(docs) > 0:
doc = docs[0]
@@ -104,10 +128,16 @@ return None
def list_cols(self):
+ """
+ List all collections.
+ """
# LangChain doesn't have collections
return [self.collection_name]
def delete_col(self):
+ """
+ Delete a collection.
+ """
logger.warning("Deleting collection")
if hasattr(self.client, "delete_collection"):
self.client.delete_collection()
@@ -117,9 +147,15 @@ self.client.delete(ids=None)
def col_info(self):
+ """
+ Get information about a collection.
+ """
return {"name": self.collection_name}
def list(self, filters=None, limit=None):
+ """
+ List all vectors in a collection.
+ """
try:
if hasattr(self.client, "_collection") and hasattr(self.client._collection, "get"):
# Convert mem0 filters to Chroma where clause if needed
@@ -139,5 +175,6 @@ return []
def reset(self):
+ """Reset the index by deleting and recreating it."""
logger.warning(f"Resetting collection: {self.collection_name}")
- self.delete_col()+ self.delete_col()
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/vector_stores/langchain.py |
Add docstrings to improve code quality |
import os
import argparse
import time
import requests
import pyarrow.parquet as pq
from multiprocessing import Pool
from nanochat.common import get_base_dir
# -----------------------------------------------------------------------------
# The specifics of the current pretraining dataset
# The URL on the internet where the data is hosted and downloaded from on demand
BASE_URL = "https://huggingface.co/datasets/karpathy/climbmix-400b-shuffle/resolve/main"
MAX_SHARD = 6542 # the last datashard is shard_06542.parquet
index_to_filename = lambda index: f"shard_{index:05d}.parquet" # format of the filenames
base_dir = get_base_dir()
DATA_DIR = os.path.join(base_dir, "base_data_climbmix")
# -----------------------------------------------------------------------------
# These functions are useful utilities to other modules, can/should be imported
def list_parquet_files(data_dir=None, warn_on_legacy=False):
data_dir = DATA_DIR if data_dir is None else data_dir
# Legacy-supporting code due to the upgrade from FinewebEdu-100B to ClimbMix-400B
# This code will eventually be deleted.
if not os.path.exists(data_dir):
if warn_on_legacy:
print()
print("=" * 80)
print(" WARNING: DATASET UPGRADE REQUIRED")
print("=" * 80)
print()
print(f" Could not find: {data_dir}")
print()
print(" nanochat recently switched from FinewebEdu-100B to ClimbMix-400B.")
print(" Everyone who does `git pull` as of March 4, 2026 is expected to see this message.")
print(" To upgrade to the new ClimbMix-400B dataset, run these two commands:")
print()
print(" python -m nanochat.dataset -n 170 # download ~170 shards, enough for GPT-2, adjust as desired")
print(" python -m scripts.tok_train # re-train tokenizer on new ClimbMix data")
print()
print(" For now, falling back to your old FinewebEdu-100B dataset...")
print("=" * 80)
print()
# attempt a fallback to the legacy data directory
data_dir = os.path.join(base_dir, "base_data")
parquet_files = sorted([
f for f in os.listdir(data_dir)
if f.endswith('.parquet') and not f.endswith('.tmp')
])
parquet_paths = [os.path.join(data_dir, f) for f in parquet_files]
return parquet_paths
def parquets_iter_batched(split, start=0, step=1):
assert split in ["train", "val"], "split must be 'train' or 'val'"
parquet_paths = list_parquet_files()
parquet_paths = parquet_paths[:-1] if split == "train" else parquet_paths[-1:]
for filepath in parquet_paths:
pf = pq.ParquetFile(filepath)
for rg_idx in range(start, pf.num_row_groups, step):
rg = pf.read_row_group(rg_idx)
texts = rg.column('text').to_pylist()
yield texts
# -----------------------------------------------------------------------------
def download_single_file(index):
# Construct the local filepath for this file and skip if it already exists
filename = index_to_filename(index)
filepath = os.path.join(DATA_DIR, filename)
if os.path.exists(filepath):
print(f"Skipping {filepath} (already exists)")
return True
# Construct the remote URL for this file
url = f"{BASE_URL}/{filename}"
print(f"Downloading {filename}...")
# Download with retries
max_attempts = 5
for attempt in range(1, max_attempts + 1):
try:
response = requests.get(url, stream=True, timeout=30)
response.raise_for_status()
# Write to temporary file first
temp_path = filepath + f".tmp"
with open(temp_path, 'wb') as f:
for chunk in response.iter_content(chunk_size=1024 * 1024): # 1MB chunks
if chunk:
f.write(chunk)
# Move temp file to final location
os.rename(temp_path, filepath)
print(f"Successfully downloaded {filename}")
return True
except (requests.RequestException, IOError) as e:
print(f"Attempt {attempt}/{max_attempts} failed for {filename}: {e}")
# Clean up any partial files
for path in [filepath + f".tmp", filepath]:
if os.path.exists(path):
try:
os.remove(path)
except:
pass
# Try a few times with exponential backoff: 2^attempt seconds
if attempt < max_attempts:
wait_time = 2 ** attempt
print(f"Waiting {wait_time} seconds before retry...")
time.sleep(wait_time)
else:
print(f"Failed to download {filename} after {max_attempts} attempts")
return False
return False
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Download pretraining dataset shards")
parser.add_argument("-n", "--num-files", type=int, default=-1, help="Number of train shards to download (default: -1), -1 = disable")
parser.add_argument("-w", "--num-workers", type=int, default=4, help="Number of parallel download workers (default: 4)")
args = parser.parse_args()
# Prepare the output directory
os.makedirs(DATA_DIR, exist_ok=True)
# The way this works is that the user specifies the number of train shards to download via the -n flag.
# In addition to that, the validation shard is *always* downloaded and is pinned to be the last shard.
num_train_shards = MAX_SHARD if args.num_files == -1 else min(args.num_files, MAX_SHARD)
ids_to_download = list(range(num_train_shards))
ids_to_download.append(MAX_SHARD) # always download the validation shard
# Download the shards
print(f"Downloading {len(ids_to_download)} shards using {args.num_workers} workers...")
print(f"Target directory: {DATA_DIR}")
print()
with Pool(processes=args.num_workers) as pool:
results = pool.map(download_single_file, ids_to_download)
# Report results
successful = sum(1 for success in results if success)
print(f"Done! Downloaded: {successful}/{len(ids_to_download)} shards to {DATA_DIR}") | --- +++ @@ -1,3 +1,11 @@+"""
+The base/pretraining dataset is a set of parquet files.
+This file contains utilities for:
+- iterating over the parquet files and yielding documents from it
+- download the files on demand if they are not on disk
+
+For details of how the dataset was prepared, see `repackage_data_reference.py`.
+"""
import os
import argparse
@@ -22,6 +30,7 @@ # These functions are useful utilities to other modules, can/should be imported
def list_parquet_files(data_dir=None, warn_on_legacy=False):
+ """ Looks into a data dir and returns full paths to all parquet files. """
data_dir = DATA_DIR if data_dir is None else data_dir
# Legacy-supporting code due to the upgrade from FinewebEdu-100B to ClimbMix-400B
@@ -56,6 +65,11 @@ return parquet_paths
def parquets_iter_batched(split, start=0, step=1):
+ """
+ Iterate through the dataset, in batches of underlying row_groups for efficiency.
+ - split can be "train" or "val". the last parquet file will be val.
+ - start/step are useful for skipping rows in DDP. e.g. start=rank, step=world_size
+ """
assert split in ["train", "val"], "split must be 'train' or 'val'"
parquet_paths = list_parquet_files()
parquet_paths = parquet_paths[:-1] if split == "train" else parquet_paths[-1:]
@@ -68,6 +82,7 @@
# -----------------------------------------------------------------------------
def download_single_file(index):
+ """ Downloads a single file index, with some backoff """
# Construct the local filepath for this file and skip if it already exists
filename = index_to_filename(index)
@@ -142,4 +157,4 @@
# Report results
successful = sum(1 for success in results if success)
- print(f"Done! Downloaded: {successful}/{len(ids_to_download)} shards to {DATA_DIR}")+ print(f"Done! Downloaded: {successful}/{len(ids_to_download)} shards to {DATA_DIR}")
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/dataset.py |
Add detailed docstrings explaining each function | import datetime
import enum
import uuid
import sqlalchemy as sa
from app.database import Base
from app.utils.categorization import get_categories_for_memory
from sqlalchemy import (
JSON,
UUID,
Boolean,
Column,
DateTime,
Enum,
ForeignKey,
Index,
Integer,
String,
Table,
event,
)
from sqlalchemy.orm import Session, relationship
def get_current_utc_time():
return datetime.datetime.now(datetime.UTC)
class MemoryState(enum.Enum):
active = "active"
paused = "paused"
archived = "archived"
deleted = "deleted"
class User(Base):
__tablename__ = "users"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
user_id = Column(String, nullable=False, unique=True, index=True)
name = Column(String, nullable=True, index=True)
email = Column(String, unique=True, nullable=True, index=True)
metadata_ = Column('metadata', JSON, default=dict)
created_at = Column(DateTime, default=get_current_utc_time, index=True)
updated_at = Column(DateTime,
default=get_current_utc_time,
onupdate=get_current_utc_time)
apps = relationship("App", back_populates="owner")
memories = relationship("Memory", back_populates="user")
class App(Base):
__tablename__ = "apps"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
owner_id = Column(UUID, ForeignKey("users.id"), nullable=False, index=True)
name = Column(String, nullable=False, index=True)
description = Column(String)
metadata_ = Column('metadata', JSON, default=dict)
is_active = Column(Boolean, default=True, index=True)
created_at = Column(DateTime, default=get_current_utc_time, index=True)
updated_at = Column(DateTime,
default=get_current_utc_time,
onupdate=get_current_utc_time)
owner = relationship("User", back_populates="apps")
memories = relationship("Memory", back_populates="app")
__table_args__ = (
sa.UniqueConstraint('owner_id', 'name', name='idx_app_owner_name'),
)
class Config(Base):
__tablename__ = "configs"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
key = Column(String, unique=True, nullable=False, index=True)
value = Column(JSON, nullable=False)
created_at = Column(DateTime, default=get_current_utc_time)
updated_at = Column(DateTime,
default=get_current_utc_time,
onupdate=get_current_utc_time)
class Memory(Base):
__tablename__ = "memories"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
user_id = Column(UUID, ForeignKey("users.id"), nullable=False, index=True)
app_id = Column(UUID, ForeignKey("apps.id"), nullable=False, index=True)
content = Column(String, nullable=False)
vector = Column(String)
metadata_ = Column('metadata', JSON, default=dict)
state = Column(Enum(MemoryState), default=MemoryState.active, index=True)
created_at = Column(DateTime, default=get_current_utc_time, index=True)
updated_at = Column(DateTime,
default=get_current_utc_time,
onupdate=get_current_utc_time)
archived_at = Column(DateTime, nullable=True, index=True)
deleted_at = Column(DateTime, nullable=True, index=True)
user = relationship("User", back_populates="memories")
app = relationship("App", back_populates="memories")
categories = relationship("Category", secondary="memory_categories", back_populates="memories")
__table_args__ = (
Index('idx_memory_user_state', 'user_id', 'state'),
Index('idx_memory_app_state', 'app_id', 'state'),
Index('idx_memory_user_app', 'user_id', 'app_id'),
)
class Category(Base):
__tablename__ = "categories"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
name = Column(String, unique=True, nullable=False, index=True)
description = Column(String)
created_at = Column(DateTime, default=datetime.datetime.now(datetime.UTC), index=True)
updated_at = Column(DateTime,
default=get_current_utc_time,
onupdate=get_current_utc_time)
memories = relationship("Memory", secondary="memory_categories", back_populates="categories")
memory_categories = Table(
"memory_categories", Base.metadata,
Column("memory_id", UUID, ForeignKey("memories.id"), primary_key=True, index=True),
Column("category_id", UUID, ForeignKey("categories.id"), primary_key=True, index=True),
Index('idx_memory_category', 'memory_id', 'category_id')
)
class AccessControl(Base):
__tablename__ = "access_controls"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
subject_type = Column(String, nullable=False, index=True)
subject_id = Column(UUID, nullable=True, index=True)
object_type = Column(String, nullable=False, index=True)
object_id = Column(UUID, nullable=True, index=True)
effect = Column(String, nullable=False, index=True)
created_at = Column(DateTime, default=get_current_utc_time, index=True)
__table_args__ = (
Index('idx_access_subject', 'subject_type', 'subject_id'),
Index('idx_access_object', 'object_type', 'object_id'),
)
class ArchivePolicy(Base):
__tablename__ = "archive_policies"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
criteria_type = Column(String, nullable=False, index=True)
criteria_id = Column(UUID, nullable=True, index=True)
days_to_archive = Column(Integer, nullable=False)
created_at = Column(DateTime, default=get_current_utc_time, index=True)
__table_args__ = (
Index('idx_policy_criteria', 'criteria_type', 'criteria_id'),
)
class MemoryStatusHistory(Base):
__tablename__ = "memory_status_history"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
memory_id = Column(UUID, ForeignKey("memories.id"), nullable=False, index=True)
changed_by = Column(UUID, ForeignKey("users.id"), nullable=False, index=True)
old_state = Column(Enum(MemoryState), nullable=False, index=True)
new_state = Column(Enum(MemoryState), nullable=False, index=True)
changed_at = Column(DateTime, default=get_current_utc_time, index=True)
__table_args__ = (
Index('idx_history_memory_state', 'memory_id', 'new_state'),
Index('idx_history_user_time', 'changed_by', 'changed_at'),
)
class MemoryAccessLog(Base):
__tablename__ = "memory_access_logs"
id = Column(UUID, primary_key=True, default=lambda: uuid.uuid4())
memory_id = Column(UUID, ForeignKey("memories.id"), nullable=False, index=True)
app_id = Column(UUID, ForeignKey("apps.id"), nullable=False, index=True)
accessed_at = Column(DateTime, default=get_current_utc_time, index=True)
access_type = Column(String, nullable=False, index=True)
metadata_ = Column('metadata', JSON, default=dict)
__table_args__ = (
Index('idx_access_memory_time', 'memory_id', 'accessed_at'),
Index('idx_access_app_time', 'app_id', 'accessed_at'),
)
def categorize_memory(memory: Memory, db: Session) -> None:
try:
# Get categories from OpenAI
categories = get_categories_for_memory(memory.content)
# Get or create categories in the database
for category_name in categories:
category = db.query(Category).filter(Category.name == category_name).first()
if not category:
category = Category(
name=category_name,
description=f"Automatically created category for {category_name}"
)
db.add(category)
db.flush() # Flush to get the category ID
# Check if the memory-category association already exists
existing = db.execute(
memory_categories.select().where(
(memory_categories.c.memory_id == memory.id) &
(memory_categories.c.category_id == category.id)
)
).first()
if not existing:
# Create the association
db.execute(
memory_categories.insert().values(
memory_id=memory.id,
category_id=category.id
)
)
db.commit()
except Exception as e:
db.rollback()
print(f"Error categorizing memory: {e}")
@event.listens_for(Memory, 'after_insert')
def after_memory_insert(mapper, connection, target):
db = Session(bind=connection)
categorize_memory(target, db)
db.close()
@event.listens_for(Memory, 'after_update')
def after_memory_update(mapper, connection, target):
db = Session(bind=connection)
categorize_memory(target, db)
db.close() | --- +++ @@ -23,6 +23,7 @@
def get_current_utc_time():
+ """Get current UTC time"""
return datetime.datetime.now(datetime.UTC)
@@ -187,6 +188,7 @@ )
def categorize_memory(memory: Memory, db: Session) -> None:
+ """Categorize a memory using OpenAI and store the categories in the database."""
try:
# Get categories from OpenAI
categories = get_categories_for_memory(memory.content)
@@ -227,6 +229,7 @@
@event.listens_for(Memory, 'after_insert')
def after_memory_insert(mapper, connection, target):
+ """Trigger categorization after a memory is inserted."""
db = Session(bind=connection)
categorize_memory(target, db)
db.close()
@@ -234,6 +237,7 @@
@event.listens_for(Memory, 'after_update')
def after_memory_update(mapper, connection, target):
+ """Trigger categorization after a memory is updated."""
db = Session(bind=connection)
categorize_memory(target, db)
- db.close()+ db.close()
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/openmemory/api/app/models.py |
Create simple docstrings for beginners |
import contextvars
import datetime
import json
import logging
import uuid
from app.database import SessionLocal
from app.models import Memory, MemoryAccessLog, MemoryState, MemoryStatusHistory
from app.utils.db import get_user_and_app
from app.utils.memory import get_memory_client
from app.utils.permissions import check_memory_access_permissions
from dotenv import load_dotenv
from fastapi import FastAPI, Request
from fastapi.routing import APIRouter
from mcp.server.fastmcp import FastMCP
from mcp.server.sse import SseServerTransport
# Load environment variables
load_dotenv()
# Initialize MCP
mcp = FastMCP("mem0-mcp-server")
# Don't initialize memory client at import time - do it lazily when needed
def get_memory_client_safe():
try:
return get_memory_client()
except Exception as e:
logging.warning(f"Failed to get memory client: {e}")
return None
# Context variables for user_id and client_name
user_id_var: contextvars.ContextVar[str] = contextvars.ContextVar("user_id")
client_name_var: contextvars.ContextVar[str] = contextvars.ContextVar("client_name")
# Create a router for MCP endpoints
mcp_router = APIRouter(prefix="/mcp")
# Initialize SSE transport
sse = SseServerTransport("/mcp/messages/")
@mcp.tool(description="Add a new memory. This method is called everytime the user informs anything about themselves, their preferences, or anything that has any relevant information which can be useful in the future conversation. This can also be called when the user asks you to remember something.")
async def add_memories(text: str) -> str:
uid = user_id_var.get(None)
client_name = client_name_var.get(None)
if not uid:
return "Error: user_id not provided"
if not client_name:
return "Error: client_name not provided"
# Get memory client safely
memory_client = get_memory_client_safe()
if not memory_client:
return "Error: Memory system is currently unavailable. Please try again later."
try:
db = SessionLocal()
try:
# Get or create user and app
user, app = get_user_and_app(db, user_id=uid, app_id=client_name)
# Check if app is active
if not app.is_active:
return f"Error: App {app.name} is currently paused on OpenMemory. Cannot create new memories."
response = memory_client.add(text,
user_id=uid,
metadata={
"source_app": "openmemory",
"mcp_client": client_name,
})
# Process the response and update database
if isinstance(response, dict) and 'results' in response:
for result in response['results']:
memory_id = uuid.UUID(result['id'])
memory = db.query(Memory).filter(Memory.id == memory_id).first()
if result['event'] == 'ADD':
if not memory:
memory = Memory(
id=memory_id,
user_id=user.id,
app_id=app.id,
content=result['memory'],
state=MemoryState.active
)
db.add(memory)
else:
memory.state = MemoryState.active
memory.content = result['memory']
# Create history entry
history = MemoryStatusHistory(
memory_id=memory_id,
changed_by=user.id,
old_state=MemoryState.deleted if memory else None,
new_state=MemoryState.active
)
db.add(history)
elif result['event'] == 'DELETE':
if memory:
memory.state = MemoryState.deleted
memory.deleted_at = datetime.datetime.now(datetime.UTC)
# Create history entry
history = MemoryStatusHistory(
memory_id=memory_id,
changed_by=user.id,
old_state=MemoryState.active,
new_state=MemoryState.deleted
)
db.add(history)
db.commit()
return json.dumps(response)
finally:
db.close()
except Exception as e:
logging.exception(f"Error adding to memory: {e}")
return f"Error adding to memory: {e}"
@mcp.tool(description="Search through stored memories. This method is called EVERYTIME the user asks anything.")
async def search_memory(query: str) -> str:
uid = user_id_var.get(None)
client_name = client_name_var.get(None)
if not uid:
return "Error: user_id not provided"
if not client_name:
return "Error: client_name not provided"
# Get memory client safely
memory_client = get_memory_client_safe()
if not memory_client:
return "Error: Memory system is currently unavailable. Please try again later."
try:
db = SessionLocal()
try:
# Get or create user and app
user, app = get_user_and_app(db, user_id=uid, app_id=client_name)
# Get accessible memory IDs based on ACL
user_memories = db.query(Memory).filter(Memory.user_id == user.id).all()
accessible_memory_ids = [memory.id for memory in user_memories if check_memory_access_permissions(db, memory, app.id)]
filters = {
"user_id": uid
}
embeddings = memory_client.embedding_model.embed(query, "search")
hits = memory_client.vector_store.search(
query=query,
vectors=embeddings,
limit=10,
filters=filters,
)
allowed = set(str(mid) for mid in accessible_memory_ids) if accessible_memory_ids else None
results = []
for h in hits:
# All vector db search functions return OutputData class
id, score, payload = h.id, h.score, h.payload
if allowed and h.id is None or h.id not in allowed:
continue
results.append({
"id": id,
"memory": payload.get("data"),
"hash": payload.get("hash"),
"created_at": payload.get("created_at"),
"updated_at": payload.get("updated_at"),
"score": score,
})
for r in results:
if r.get("id"):
access_log = MemoryAccessLog(
memory_id=uuid.UUID(r["id"]),
app_id=app.id,
access_type="search",
metadata_={
"query": query,
"score": r.get("score"),
"hash": r.get("hash"),
},
)
db.add(access_log)
db.commit()
return json.dumps({"results": results}, indent=2)
finally:
db.close()
except Exception as e:
logging.exception(e)
return f"Error searching memory: {e}"
@mcp.tool(description="List all memories in the user's memory")
async def list_memories() -> str:
uid = user_id_var.get(None)
client_name = client_name_var.get(None)
if not uid:
return "Error: user_id not provided"
if not client_name:
return "Error: client_name not provided"
# Get memory client safely
memory_client = get_memory_client_safe()
if not memory_client:
return "Error: Memory system is currently unavailable. Please try again later."
try:
db = SessionLocal()
try:
# Get or create user and app
user, app = get_user_and_app(db, user_id=uid, app_id=client_name)
# Get all memories
memories = memory_client.get_all(user_id=uid)
filtered_memories = []
# Filter memories based on permissions
user_memories = db.query(Memory).filter(Memory.user_id == user.id).all()
accessible_memory_ids = [memory.id for memory in user_memories if check_memory_access_permissions(db, memory, app.id)]
if isinstance(memories, dict) and 'results' in memories:
for memory_data in memories['results']:
if 'id' in memory_data:
memory_id = uuid.UUID(memory_data['id'])
if memory_id in accessible_memory_ids:
# Create access log entry
access_log = MemoryAccessLog(
memory_id=memory_id,
app_id=app.id,
access_type="list",
metadata_={
"hash": memory_data.get('hash')
}
)
db.add(access_log)
filtered_memories.append(memory_data)
db.commit()
else:
for memory in memories:
memory_id = uuid.UUID(memory['id'])
memory_obj = db.query(Memory).filter(Memory.id == memory_id).first()
if memory_obj and check_memory_access_permissions(db, memory_obj, app.id):
# Create access log entry
access_log = MemoryAccessLog(
memory_id=memory_id,
app_id=app.id,
access_type="list",
metadata_={
"hash": memory.get('hash')
}
)
db.add(access_log)
filtered_memories.append(memory)
db.commit()
return json.dumps(filtered_memories, indent=2)
finally:
db.close()
except Exception as e:
logging.exception(f"Error getting memories: {e}")
return f"Error getting memories: {e}"
@mcp.tool(description="Delete specific memories by their IDs")
async def delete_memories(memory_ids: list[str]) -> str:
uid = user_id_var.get(None)
client_name = client_name_var.get(None)
if not uid:
return "Error: user_id not provided"
if not client_name:
return "Error: client_name not provided"
# Get memory client safely
memory_client = get_memory_client_safe()
if not memory_client:
return "Error: Memory system is currently unavailable. Please try again later."
try:
db = SessionLocal()
try:
# Get or create user and app
user, app = get_user_and_app(db, user_id=uid, app_id=client_name)
# Convert string IDs to UUIDs and filter accessible ones
requested_ids = [uuid.UUID(mid) for mid in memory_ids]
user_memories = db.query(Memory).filter(Memory.user_id == user.id).all()
accessible_memory_ids = [memory.id for memory in user_memories if check_memory_access_permissions(db, memory, app.id)]
# Only delete memories that are both requested and accessible
ids_to_delete = [mid for mid in requested_ids if mid in accessible_memory_ids]
if not ids_to_delete:
return "Error: No accessible memories found with provided IDs"
# Delete from vector store
for memory_id in ids_to_delete:
try:
memory_client.delete(str(memory_id))
except Exception as delete_error:
logging.warning(f"Failed to delete memory {memory_id} from vector store: {delete_error}")
# Update each memory's state and create history entries
now = datetime.datetime.now(datetime.UTC)
for memory_id in ids_to_delete:
memory = db.query(Memory).filter(Memory.id == memory_id).first()
if memory:
# Update memory state
memory.state = MemoryState.deleted
memory.deleted_at = now
# Create history entry
history = MemoryStatusHistory(
memory_id=memory_id,
changed_by=user.id,
old_state=MemoryState.active,
new_state=MemoryState.deleted
)
db.add(history)
# Create access log entry
access_log = MemoryAccessLog(
memory_id=memory_id,
app_id=app.id,
access_type="delete",
metadata_={"operation": "delete_by_id"}
)
db.add(access_log)
db.commit()
return f"Successfully deleted {len(ids_to_delete)} memories"
finally:
db.close()
except Exception as e:
logging.exception(f"Error deleting memories: {e}")
return f"Error deleting memories: {e}"
@mcp.tool(description="Delete all memories in the user's memory")
async def delete_all_memories() -> str:
uid = user_id_var.get(None)
client_name = client_name_var.get(None)
if not uid:
return "Error: user_id not provided"
if not client_name:
return "Error: client_name not provided"
# Get memory client safely
memory_client = get_memory_client_safe()
if not memory_client:
return "Error: Memory system is currently unavailable. Please try again later."
try:
db = SessionLocal()
try:
# Get or create user and app
user, app = get_user_and_app(db, user_id=uid, app_id=client_name)
user_memories = db.query(Memory).filter(Memory.user_id == user.id).all()
accessible_memory_ids = [memory.id for memory in user_memories if check_memory_access_permissions(db, memory, app.id)]
# delete the accessible memories only
for memory_id in accessible_memory_ids:
try:
memory_client.delete(str(memory_id))
except Exception as delete_error:
logging.warning(f"Failed to delete memory {memory_id} from vector store: {delete_error}")
# Update each memory's state and create history entries
now = datetime.datetime.now(datetime.UTC)
for memory_id in accessible_memory_ids:
memory = db.query(Memory).filter(Memory.id == memory_id).first()
# Update memory state
memory.state = MemoryState.deleted
memory.deleted_at = now
# Create history entry
history = MemoryStatusHistory(
memory_id=memory_id,
changed_by=user.id,
old_state=MemoryState.active,
new_state=MemoryState.deleted
)
db.add(history)
# Create access log entry
access_log = MemoryAccessLog(
memory_id=memory_id,
app_id=app.id,
access_type="delete_all",
metadata_={"operation": "bulk_delete"}
)
db.add(access_log)
db.commit()
return "Successfully deleted all memories"
finally:
db.close()
except Exception as e:
logging.exception(f"Error deleting memories: {e}")
return f"Error deleting memories: {e}"
@mcp_router.get("/{client_name}/sse/{user_id}")
async def handle_sse(request: Request):
# Extract user_id and client_name from path parameters
uid = request.path_params.get("user_id")
user_token = user_id_var.set(uid or "")
client_name = request.path_params.get("client_name")
client_token = client_name_var.set(client_name or "")
try:
# Handle SSE connection
async with sse.connect_sse(
request.scope,
request.receive,
request._send,
) as (read_stream, write_stream):
await mcp._mcp_server.run(
read_stream,
write_stream,
mcp._mcp_server.create_initialization_options(),
)
finally:
# Clean up context variables
user_id_var.reset(user_token)
client_name_var.reset(client_token)
@mcp_router.post("/messages/")
async def handle_get_message(request: Request):
return await handle_post_message(request)
@mcp_router.post("/{client_name}/sse/{user_id}/messages/")
async def handle_post_message(request: Request):
return await handle_post_message(request)
async def handle_post_message(request: Request):
try:
body = await request.body()
# Create a simple receive function that returns the body
async def receive():
return {"type": "http.request", "body": body, "more_body": False}
# Create a simple send function that does nothing
async def send(message):
return {}
# Call handle_post_message with the correct arguments
await sse.handle_post_message(request.scope, receive, send)
# Return a success response
return {"status": "ok"}
finally:
pass
def setup_mcp_server(app: FastAPI):
mcp._mcp_server.name = "mem0-mcp-server"
# Include MCP router in the FastAPI app
app.include_router(mcp_router) | --- +++ @@ -1,3 +1,19 @@+"""
+MCP Server for OpenMemory with resilient memory client handling.
+
+This module implements an MCP (Model Context Protocol) server that provides
+memory operations for OpenMemory. The memory client is initialized lazily
+to prevent server crashes when external dependencies (like Ollama) are
+unavailable. If the memory client cannot be initialized, the server will
+continue running with limited functionality and appropriate error messages.
+
+Key features:
+- Lazy memory client initialization
+- Graceful error handling for unavailable dependencies
+- Fallback to database-only mode when vector store is unavailable
+- Proper logging for debugging connection issues
+- Environment variable parsing for API keys
+"""
import contextvars
import datetime
@@ -24,6 +40,7 @@
# Don't initialize memory client at import time - do it lazily when needed
def get_memory_client_safe():
+ """Get memory client with error handling. Returns None if client cannot be initialized."""
try:
return get_memory_client()
except Exception as e:
@@ -412,6 +429,7 @@
@mcp_router.get("/{client_name}/sse/{user_id}")
async def handle_sse(request: Request):
+ """Handle SSE connections for a specific user and client"""
# Extract user_id and client_name from path parameters
uid = request.path_params.get("user_id")
user_token = user_id_var.set(uid or "")
@@ -446,6 +464,7 @@ return await handle_post_message(request)
async def handle_post_message(request: Request):
+ """Handle POST messages for SSE"""
try:
body = await request.body()
@@ -466,7 +485,8 @@ pass
def setup_mcp_server(app: FastAPI):
+ """Setup MCP server with the FastAPI application"""
mcp._mcp_server.name = "mem0-mcp-server"
# Include MCP router in the FastAPI app
- app.include_router(mcp_router)+ app.include_router(mcp_router)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/openmemory/api/app/mcp_server.py |
Add docstrings to incomplete code | import logging
from mem0.memory.utils import format_entities, sanitize_relationship_for_cypher
try:
from langchain_neo4j import Neo4jGraph
except ImportError:
raise ImportError("langchain_neo4j is not installed. Please install it using pip install langchain-neo4j")
try:
from rank_bm25 import BM25Okapi
except ImportError:
raise ImportError("rank_bm25 is not installed. Please install it using pip install rank-bm25")
from mem0.graphs.tools import (
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
DELETE_MEMORY_TOOL_GRAPH,
EXTRACT_ENTITIES_STRUCT_TOOL,
EXTRACT_ENTITIES_TOOL,
RELATIONS_STRUCT_TOOL,
RELATIONS_TOOL,
)
from mem0.graphs.utils import EXTRACT_RELATIONS_PROMPT, get_delete_messages
from mem0.utils.factory import EmbedderFactory, LlmFactory
logger = logging.getLogger(__name__)
class MemoryGraph:
def __init__(self, config):
self.config = config
self.graph = Neo4jGraph(
url=self.config.graph_store.config.url,
username=self.config.graph_store.config.username,
password=self.config.graph_store.config.password,
database=self.config.graph_store.config.database,
refresh_schema=False,
driver_config={"notifications_min_severity": "OFF"},
)
self.embedding_model = EmbedderFactory.create(
self.config.embedder.provider, self.config.embedder.config, self.config.vector_store.config
)
self.node_label = ":`__Entity__`" if self.config.graph_store.config.base_label else ""
if self.config.graph_store.config.base_label:
# Safely add user_id index
try:
self.graph.query(f"CREATE INDEX entity_single IF NOT EXISTS FOR (n {self.node_label}) ON (n.user_id)")
except Exception:
pass
try: # Safely try to add composite index (Enterprise only)
self.graph.query(
f"CREATE INDEX entity_composite IF NOT EXISTS FOR (n {self.node_label}) ON (n.name, n.user_id)"
)
except Exception:
pass
# Default to openai if no specific provider is configured
self.llm_provider = "openai"
if self.config.llm and self.config.llm.provider:
self.llm_provider = self.config.llm.provider
if self.config.graph_store and self.config.graph_store.llm and self.config.graph_store.llm.provider:
self.llm_provider = self.config.graph_store.llm.provider
# Get LLM config with proper null checks
llm_config = None
if self.config.graph_store and self.config.graph_store.llm and hasattr(self.config.graph_store.llm, "config"):
llm_config = self.config.graph_store.llm.config
elif hasattr(self.config.llm, "config"):
llm_config = self.config.llm.config
self.llm = LlmFactory.create(self.llm_provider, llm_config)
self.user_id = None
# Use threshold from graph_store config, default to 0.7 for backward compatibility
self.threshold = self.config.graph_store.threshold if hasattr(self.config.graph_store, 'threshold') else 0.7
def add(self, data, filters):
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
to_be_deleted = self._get_delete_entities_from_search_output(search_output, data, filters)
# TODO: Batch queries with APOC plugin
# TODO: Add more filter support
deleted_entities = self._delete_entities(to_be_deleted, filters)
added_entities = self._add_entities(to_be_added, filters, entity_type_map)
return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=100):
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
if not search_output:
return []
search_outputs_sequence = [
[item["source"], item["relationship"], item["destination"]] for item in search_output
]
bm25 = BM25Okapi(search_outputs_sequence)
tokenized_query = query.split(" ")
reranked_results = bm25.get_top_n(tokenized_query, search_outputs_sequence, n=5)
search_results = []
for item in reranked_results:
search_results.append({"source": item[0], "relationship": item[1], "destination": item[2]})
logger.info(f"Returned {len(search_results)} search results")
return search_results
def delete_all(self, filters):
# Build node properties for filtering
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
if filters.get("run_id"):
node_props.append("run_id: $run_id")
node_props_str = ", ".join(node_props)
cypher = f"""
MATCH (n {self.node_label} {{{node_props_str}}})
DETACH DELETE n
"""
params = {"user_id": filters["user_id"]}
if filters.get("agent_id"):
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
params["run_id"] = filters["run_id"]
self.graph.query(cypher, params=params)
def get_all(self, filters, limit=100):
params = {"user_id": filters["user_id"], "limit": limit}
# Build node properties based on filters
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
node_props.append("run_id: $run_id")
params["run_id"] = filters["run_id"]
node_props_str = ", ".join(node_props)
query = f"""
MATCH (n {self.node_label} {{{node_props_str}}})-[r]->(m {self.node_label} {{{node_props_str}}})
RETURN n.name AS source, type(r) AS relationship, m.name AS target
LIMIT $limit
"""
results = self.graph.query(query, params=params)
final_results = []
for result in results:
final_results.append(
{
"source": result["source"],
"relationship": result["relationship"],
"target": result["target"],
}
)
logger.info(f"Retrieved {len(final_results)} relationships")
return final_results
def _retrieve_nodes_from_data(self, data, filters):
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
search_results = self.llm.generate_response(
messages=[
{
"role": "system",
"content": f"You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use {filters['user_id']} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question.",
},
{"role": "user", "content": data},
],
tools=_tools,
)
entity_type_map = {}
try:
for tool_call in search_results["tool_calls"]:
if tool_call["name"] != "extract_entities":
continue
for item in tool_call.get("arguments", {}).get("entities", []):
entity_type_map[item["entity"]] = item["entity_type"]
except Exception as e:
logger.exception(
f"Error in search tool: {e}, llm_provider={self.llm_provider}, search_results={search_results}"
)
entity_type_map = {k.lower().replace(" ", "_"): v.lower().replace(" ", "_") for k, v in entity_type_map.items()}
logger.debug(f"Entity type map: {entity_type_map}\n search_results={search_results}")
return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
if filters.get("agent_id"):
user_identity += f", agent_id: {filters['agent_id']}"
if filters.get("run_id"):
user_identity += f", run_id: {filters['run_id']}"
if self.config.graph_store.custom_prompt:
system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
# Add the custom prompt line if configured
system_content = system_content.replace("CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}")
messages = [
{"role": "system", "content": system_content},
{"role": "user", "content": data},
]
else:
system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
messages = [
{"role": "system", "content": system_content},
{"role": "user", "content": f"List of entities: {list(entity_type_map.keys())}. \n\nText: {data}"},
]
_tools = [RELATIONS_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [RELATIONS_STRUCT_TOOL]
extracted_entities = self.llm.generate_response(
messages=messages,
tools=_tools,
)
entities = []
if extracted_entities.get("tool_calls"):
entities = extracted_entities["tool_calls"][0].get("arguments", {}).get("entities", [])
entities = self._remove_spaces_from_entities(entities)
logger.debug(f"Extracted entities: {entities}")
return entities
def _search_graph_db(self, node_list, filters, limit=100):
result_relations = []
# Build node properties for filtering
node_props = ["user_id: $user_id"]
if filters.get("agent_id"):
node_props.append("agent_id: $agent_id")
if filters.get("run_id"):
node_props.append("run_id: $run_id")
node_props_str = ", ".join(node_props)
for node in node_list:
n_embedding = self.embedding_model.embed(node)
cypher_query = f"""
MATCH (n {self.node_label} {{{node_props_str}}})
WHERE n.embedding IS NOT NULL
WITH n, round(2 * vector.similarity.cosine(n.embedding, $n_embedding) - 1, 4) AS similarity // denormalize for backward compatibility
WHERE similarity >= $threshold
CALL {{
WITH n
MATCH (n)-[r]->(m {self.node_label} {{{node_props_str}}})
RETURN n.name AS source, elementId(n) AS source_id, type(r) AS relationship, elementId(r) AS relation_id, m.name AS destination, elementId(m) AS destination_id
UNION
WITH n
MATCH (n)<-[r]-(m {self.node_label} {{{node_props_str}}})
RETURN m.name AS source, elementId(m) AS source_id, type(r) AS relationship, elementId(r) AS relation_id, n.name AS destination, elementId(n) AS destination_id
}}
WITH distinct source, source_id, relationship, relation_id, destination, destination_id, similarity
RETURN source, source_id, relationship, relation_id, destination, destination_id, similarity
ORDER BY similarity DESC
LIMIT $limit
"""
params = {
"n_embedding": n_embedding,
"threshold": self.threshold,
"user_id": filters["user_id"],
"limit": limit,
}
if filters.get("agent_id"):
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
params["run_id"] = filters["run_id"]
ans = self.graph.query(cypher_query, params=params)
result_relations.extend(ans)
return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
search_output_string = format_entities(search_output)
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
if filters.get("agent_id"):
user_identity += f", agent_id: {filters['agent_id']}"
if filters.get("run_id"):
user_identity += f", run_id: {filters['run_id']}"
system_prompt, user_prompt = get_delete_messages(search_output_string, data, user_identity)
_tools = [DELETE_MEMORY_TOOL_GRAPH]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
]
memory_updates = self.llm.generate_response(
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
tools=_tools,
)
to_be_deleted = []
for item in memory_updates.get("tool_calls", []):
if item.get("name") == "delete_graph_memory":
to_be_deleted.append(item.get("arguments"))
# Clean entities formatting
to_be_deleted = self._remove_spaces_from_entities(to_be_deleted)
logger.debug(f"Deleted relationships: {to_be_deleted}")
return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
results = []
for item in to_be_deleted:
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# Build the agent filter for the query
params = {
"source_name": source,
"dest_name": destination,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
if run_id:
params["run_id"] = run_id
# Build node properties for filtering
source_props = ["name: $source_name", "user_id: $user_id"]
dest_props = ["name: $dest_name", "user_id: $user_id"]
if agent_id:
source_props.append("agent_id: $agent_id")
dest_props.append("agent_id: $agent_id")
if run_id:
source_props.append("run_id: $run_id")
dest_props.append("run_id: $run_id")
source_props_str = ", ".join(source_props)
dest_props_str = ", ".join(dest_props)
# Delete the specific relationship between nodes
cypher = f"""
MATCH (n {self.node_label} {{{source_props_str}}})
-[r:{relationship}]->
(m {self.node_label} {{{dest_props_str}}})
DELETE r
RETURN
n.name AS source,
m.name AS target,
type(r) AS relationship
"""
result = self.graph.query(cypher, params=params)
results.append(result)
return results
def _add_entities(self, to_be_added, filters, entity_type_map):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
results = []
for item in to_be_added:
# entities
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# types
source_type = entity_type_map.get(source, "__User__")
source_label = self.node_label if self.node_label else f":`{source_type}`"
source_extra_set = f", source:`{source_type}`" if self.node_label else ""
destination_type = entity_type_map.get(destination, "__User__")
destination_label = self.node_label if self.node_label else f":`{destination_type}`"
destination_extra_set = f", destination:`{destination_type}`" if self.node_label else ""
# embeddings
source_embedding = self.embedding_model.embed(source)
dest_embedding = self.embedding_model.embed(destination)
# search for the nodes with the closest embeddings
source_node_search_result = self._search_source_node(source_embedding, filters, threshold=self.threshold)
destination_node_search_result = self._search_destination_node(dest_embedding, filters, threshold=self.threshold)
# TODO: Create a cypher query and common params for all the cases
if not destination_node_search_result and source_node_search_result:
# Build destination MERGE properties
merge_props = ["name: $destination_name", "user_id: $user_id"]
if agent_id:
merge_props.append("agent_id: $agent_id")
if run_id:
merge_props.append("run_id: $run_id")
merge_props_str = ", ".join(merge_props)
cypher = f"""
MATCH (source)
WHERE elementId(source) = $source_id
SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
MERGE (destination {destination_label} {{{merge_props_str}}})
ON CREATE SET
destination.created = timestamp(),
destination.mentions = 1
{destination_extra_set}
ON MATCH SET
destination.mentions = coalesce(destination.mentions, 0) + 1
WITH source, destination
CALL db.create.setNodeVectorProperty(destination, 'embedding', $destination_embedding)
WITH source, destination
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"source_id": source_node_search_result[0]["elementId(source_candidate)"],
"destination_name": destination,
"destination_embedding": dest_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
if run_id:
params["run_id"] = run_id
elif destination_node_search_result and not source_node_search_result:
# Build source MERGE properties
merge_props = ["name: $source_name", "user_id: $user_id"]
if agent_id:
merge_props.append("agent_id: $agent_id")
if run_id:
merge_props.append("run_id: $run_id")
merge_props_str = ", ".join(merge_props)
cypher = f"""
MATCH (destination)
WHERE elementId(destination) = $destination_id
SET destination.mentions = coalesce(destination.mentions, 0) + 1
WITH destination
MERGE (source {source_label} {{{merge_props_str}}})
ON CREATE SET
source.created = timestamp(),
source.mentions = 1
{source_extra_set}
ON MATCH SET
source.mentions = coalesce(source.mentions, 0) + 1
WITH source, destination
CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
WITH source, destination
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp(),
r.mentions = 1
ON MATCH SET
r.mentions = coalesce(r.mentions, 0) + 1
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"destination_id": destination_node_search_result[0]["elementId(destination_candidate)"],
"source_name": source,
"source_embedding": source_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
if run_id:
params["run_id"] = run_id
elif source_node_search_result and destination_node_search_result:
cypher = f"""
MATCH (source)
WHERE elementId(source) = $source_id
SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
MATCH (destination)
WHERE elementId(destination) = $destination_id
SET destination.mentions = coalesce(destination.mentions, 0) + 1
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created_at = timestamp(),
r.updated_at = timestamp(),
r.mentions = 1
ON MATCH SET r.mentions = coalesce(r.mentions, 0) + 1
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"source_id": source_node_search_result[0]["elementId(source_candidate)"],
"destination_id": destination_node_search_result[0]["elementId(destination_candidate)"],
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
if run_id:
params["run_id"] = run_id
else:
# Build dynamic MERGE props for both source and destination
source_props = ["name: $source_name", "user_id: $user_id"]
dest_props = ["name: $dest_name", "user_id: $user_id"]
if agent_id:
source_props.append("agent_id: $agent_id")
dest_props.append("agent_id: $agent_id")
if run_id:
source_props.append("run_id: $run_id")
dest_props.append("run_id: $run_id")
source_props_str = ", ".join(source_props)
dest_props_str = ", ".join(dest_props)
cypher = f"""
MERGE (source {source_label} {{{source_props_str}}})
ON CREATE SET source.created = timestamp(),
source.mentions = 1
{source_extra_set}
ON MATCH SET source.mentions = coalesce(source.mentions, 0) + 1
WITH source
CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
WITH source
MERGE (destination {destination_label} {{{dest_props_str}}})
ON CREATE SET destination.created = timestamp(),
destination.mentions = 1
{destination_extra_set}
ON MATCH SET destination.mentions = coalesce(destination.mentions, 0) + 1
WITH source, destination
CALL db.create.setNodeVectorProperty(destination, 'embedding', $dest_embedding)
WITH source, destination
MERGE (source)-[rel:{relationship}]->(destination)
ON CREATE SET rel.created = timestamp(), rel.mentions = 1
ON MATCH SET rel.mentions = coalesce(rel.mentions, 0) + 1
RETURN source.name AS source, type(rel) AS relationship, destination.name AS target
"""
params = {
"source_name": source,
"dest_name": destination,
"source_embedding": source_embedding,
"dest_embedding": dest_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
if run_id:
params["run_id"] = run_id
result = self.graph.query(cypher, params=params)
results.append(result)
return results
def _remove_spaces_from_entities(self, entity_list):
for item in entity_list:
item["source"] = item["source"].lower().replace(" ", "_")
# Use the sanitization function for relationships to handle special characters
item["relationship"] = sanitize_relationship_for_cypher(item["relationship"].lower().replace(" ", "_"))
item["destination"] = item["destination"].lower().replace(" ", "_")
return entity_list
def _search_source_node(self, source_embedding, filters, threshold=0.9):
# Build WHERE conditions
where_conditions = ["source_candidate.embedding IS NOT NULL", "source_candidate.user_id = $user_id"]
if filters.get("agent_id"):
where_conditions.append("source_candidate.agent_id = $agent_id")
if filters.get("run_id"):
where_conditions.append("source_candidate.run_id = $run_id")
where_clause = " AND ".join(where_conditions)
cypher = f"""
MATCH (source_candidate {self.node_label})
WHERE {where_clause}
WITH source_candidate,
round(2 * vector.similarity.cosine(source_candidate.embedding, $source_embedding) - 1, 4) AS source_similarity // denormalize for backward compatibility
WHERE source_similarity >= $threshold
WITH source_candidate, source_similarity
ORDER BY source_similarity DESC
LIMIT 1
RETURN elementId(source_candidate)
"""
params = {
"source_embedding": source_embedding,
"user_id": filters["user_id"],
"threshold": threshold,
}
if filters.get("agent_id"):
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
params["run_id"] = filters["run_id"]
result = self.graph.query(cypher, params=params)
return result
def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
# Build WHERE conditions
where_conditions = ["destination_candidate.embedding IS NOT NULL", "destination_candidate.user_id = $user_id"]
if filters.get("agent_id"):
where_conditions.append("destination_candidate.agent_id = $agent_id")
if filters.get("run_id"):
where_conditions.append("destination_candidate.run_id = $run_id")
where_clause = " AND ".join(where_conditions)
cypher = f"""
MATCH (destination_candidate {self.node_label})
WHERE {where_clause}
WITH destination_candidate,
round(2 * vector.similarity.cosine(destination_candidate.embedding, $destination_embedding) - 1, 4) AS destination_similarity // denormalize for backward compatibility
WHERE destination_similarity >= $threshold
WITH destination_candidate, destination_similarity
ORDER BY destination_similarity DESC
LIMIT 1
RETURN elementId(destination_candidate)
"""
params = {
"destination_embedding": destination_embedding,
"user_id": filters["user_id"],
"threshold": threshold,
}
if filters.get("agent_id"):
params["agent_id"] = filters["agent_id"]
if filters.get("run_id"):
params["run_id"] = filters["run_id"]
result = self.graph.query(cypher, params=params)
return result
# Reset is not defined in base.py
def reset(self):
logger.warning("Clearing graph...")
cypher_query = """
MATCH (n) DETACH DELETE n
"""
return self.graph.query(cypher_query) | --- +++ @@ -74,6 +74,13 @@ self.threshold = self.config.graph_store.threshold if hasattr(self.config.graph_store, 'threshold') else 0.7
def add(self, data, filters):
+ """
+ Adds data to the graph.
+
+ Args:
+ data (str): The data to add to the graph.
+ filters (dict): A dictionary containing filters to be applied during the addition.
+ """
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -87,6 +94,19 @@ return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=100):
+ """
+ Search for memories and related graph data.
+
+ Args:
+ query (str): Query to search for.
+ filters (dict): A dictionary containing filters to be applied during the search.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing:
+ - "contexts": List of search results from the base data store.
+ - "entities": List of related graph data based on the query.
+ """
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -130,6 +150,16 @@ self.graph.query(cypher, params=params)
def get_all(self, filters, limit=100):
+ """
+ Retrieves all nodes and relationships from the graph database based on optional filtering criteria.
+ Args:
+ filters (dict): A dictionary containing filters to be applied during the retrieval.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+ Returns:
+ list: A list of dictionaries, each containing:
+ - 'contexts': The base data store response for each memory.
+ - 'entities': A list of strings representing the nodes and relationships
+ """
params = {"user_id": filters["user_id"], "limit": limit}
# Build node properties based on filters
@@ -164,6 +194,7 @@ return final_results
def _retrieve_nodes_from_data(self, data, filters):
+ """Extracts all the entities mentioned in the query."""
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
@@ -196,6 +227,7 @@ return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
+ """Establish relations among the extracted nodes."""
# Compose user identification string for prompt
user_identity = f"user_id: {filters['user_id']}"
@@ -237,6 +269,7 @@ return entities
def _search_graph_db(self, node_list, filters, limit=100):
+ """Search similar nodes among and their respective incoming and outgoing relations."""
result_relations = []
# Build node properties for filtering
@@ -287,6 +320,7 @@ return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
+ """Get the entities to be deleted from the search output."""
search_output_string = format_entities(search_output)
# Compose user identification string for prompt
@@ -322,6 +356,7 @@ return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
+ """Delete the entities from the graph."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
@@ -376,6 +411,7 @@ return results
def _add_entities(self, to_be_added, filters, entity_type_map):
+ """Add the new entities to the graph. Merge the nodes if they already exist."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
run_id = filters.get("run_id", None)
@@ -655,8 +691,9 @@
# Reset is not defined in base.py
def reset(self):
+ """Reset the graph by clearing all nodes and relationships."""
logger.warning("Clearing graph...")
cypher_query = """
MATCH (n) DETACH DELETE n
"""
- return self.graph.query(cypher_query)+ return self.graph.query(cypher_query)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/memory/graph_memory.py |
Add docstrings with type hints explained | import random
from jinja2 import Template
import torch
import torch.distributed as dist
# -----------------------------------------------------------------------------
# Prompt rendering utilities
def render_prompts_mc(item, continuation_delimiter, fewshot_examples=None):
template_str = """
{%- for example in fewshot_examples -%}
{{ example.query }}{{ continuation_delimiter }}{{ example.choices[example.gold] }}
{% endfor -%}
{{ item.query }}{{ continuation_delimiter }}{{ choice }}""".strip()
template = Template(template_str)
fewshot_examples = fewshot_examples or []
context = {
'fewshot_examples': fewshot_examples,
'continuation_delimiter': continuation_delimiter,
'item': item
}
prompts = [template.render(choice=choice, **context) for choice in item['choices']]
return prompts
def render_prompts_schema(item, continuation_delimiter, fewshot_examples=None):
template_str = """
{%- for example in fewshot_examples -%}
{{ example.context_options[example.gold] }}{{ continuation_delimiter }}{{ example.continuation }}
{% endfor -%}
{{ context }}{{ continuation_delimiter }}{{ item.continuation }}""".strip()
template = Template(template_str)
fewshot_examples = fewshot_examples or []
context = {
'fewshot_examples': fewshot_examples,
'continuation_delimiter': continuation_delimiter,
'item': item
}
prompts = [template.render(context=context_option, **context)
for context_option in item['context_options']]
return prompts
def render_prompts_lm(item, continuation_delimiter, fewshot_examples=None):
template_str = """
{%- for example in fewshot_examples -%}
{{ example.context | trim }}{{ continuation_delimiter }}{{ example.continuation }}
{% endfor -%}
{{ item.context | trim }}{{ continuation_delimiter }}{% if include_continuation %}{{ item.continuation }}{% endif %}""".strip()
template = Template(template_str)
fewshot_examples = fewshot_examples or []
context = {
'fewshot_examples': fewshot_examples,
'continuation_delimiter': continuation_delimiter,
'item': item
}
# Return two prompts: without and with the continuation
prompt_without = template.render(include_continuation=False, **context)
prompt_with = template.render(include_continuation=True, **context)
# Due to the way the data seems to be stored, I think I need to strip in the case of LM here.
# Otherwise we may get trailing whitespaces in prompt_without (which get absorbed into the next
# token in prompt_with), meaning we don't get a nice and clean prefix in the token space
# to detect the final continuation. Tokenizers...
prompt_without = prompt_without.strip()
return [prompt_without, prompt_with]
def find_common_length(token_sequences, direction='left'):
min_len = min(len(seq) for seq in token_sequences)
indices = {
'left': range(min_len),
'right': range(-1, -min_len-1, -1)
}[direction]
# Find the first position where the token sequences differ
for i, idx in enumerate(indices):
token = token_sequences[0][idx]
if not all(seq[idx] == token for seq in token_sequences):
return i
return min_len
def stack_sequences(tokens, pad_token_id):
bsz, seq_len = len(tokens), max(len(x) for x in tokens)
input_ids = torch.full((bsz, seq_len), pad_token_id, dtype=torch.long)
for i, x in enumerate(tokens):
input_ids[i, :len(x)] = torch.tensor(x, dtype=torch.long)
return input_ids
def batch_sequences_mc(tokenizer, prompts):
# In multiple choice, contexts are the same but the continuation is different (common prefix)
tokens = tokenizer(prompts, prepend=tokenizer.get_bos_token_id())
# figure out the start and end of each continuation
answer_start_idx = find_common_length(tokens, direction='left')
start_indices = [answer_start_idx] * len(prompts)
end_indices = [len(x) for x in tokens]
return tokens, start_indices, end_indices
def batch_sequences_schema(tokenizer, prompts):
# In schema tasks, contexts vary but continuation is the same (common suffix)
tokens = tokenizer(prompts, prepend=tokenizer.get_bos_token_id())
# figure out the start and end of each context
suffix_length = find_common_length(tokens, direction='right')
end_indices = [len(x) for x in tokens]
start_indices = [ei - suffix_length for ei in end_indices]
return tokens, start_indices, end_indices
def batch_sequences_lm(tokenizer, prompts):
# In LM tasks, we have two prompts: without and with continuation
tokens = tokenizer(prompts, prepend=tokenizer.get_bos_token_id())
tokens_without, tokens_with = tokens
start_idx, end_idx = len(tokens_without), len(tokens_with)
assert start_idx < end_idx, "prompt without is supposed to be a prefix of prompt with"
assert tokens_without == tokens_with[:start_idx], "prompt without is supposed to be a prefix of prompt with"
# we only need the with continuation prompt in the LM task, i.e. batch size of 1
return [tokens_with], [start_idx], [end_idx]
@torch.no_grad()
def forward_model(model, input_ids):
batch_size, seq_len = input_ids.size()
outputs = model(input_ids)
# Roll the tensor to the left by one position to get the (autoregressive) target ids
target_ids = torch.roll(input_ids, shifts=-1, dims=1)
# Calculate cross entropy at all positions
losses = torch.nn.functional.cross_entropy(
outputs.view(batch_size * seq_len, -1),
target_ids.view(batch_size * seq_len),
reduction='none'
).view(batch_size, seq_len)
# Set the last column to be nan because there is no autoregressive loss there
losses[:, -1] = float('nan')
# Get the argmax predictions at each position
predictions = outputs.argmax(dim=-1)
return losses, predictions
@torch.no_grad()
def evaluate_example(idx, model, tokenizer, data, device, task_meta):
item = data[idx]
task_type = task_meta['task_type']
num_fewshot = task_meta['num_fewshot']
continuation_delimiter = task_meta['continuation_delimiter']
# Sample few-shot examples (excluding current item)
fewshot_examples = []
if num_fewshot > 0:
rng = random.Random(1234 + idx)
available_indices = [i for i in range(len(data)) if i != idx]
fewshot_indices = rng.sample(available_indices, num_fewshot)
fewshot_examples = [data[i] for i in fewshot_indices]
# Render prompts and batch sequences based on task type
if task_type == 'multiple_choice':
prompts = render_prompts_mc(item, continuation_delimiter, fewshot_examples)
tokens, start_idxs, end_idxs = batch_sequences_mc(tokenizer, prompts)
elif task_type == 'schema':
prompts = render_prompts_schema(item, continuation_delimiter, fewshot_examples)
tokens, start_idxs, end_idxs = batch_sequences_schema(tokenizer, prompts)
elif task_type == 'language_modeling':
prompts = render_prompts_lm(item, continuation_delimiter, fewshot_examples)
tokens, start_idxs, end_idxs = batch_sequences_lm(tokenizer, prompts)
else:
raise ValueError(f"Unsupported task type: {task_type}")
# Some models can't forward sequences beyond a certain length (e.g. GPT-2)
# In these cases, we have to truncate sequences to max length and adjust the indices
if hasattr(model, 'max_seq_len') and model.max_seq_len is not None:
max_tokens = model.max_seq_len
new_tokens, new_start_idxs, new_end_idxs = [], [], []
for t, s, e in zip(tokens, start_idxs, end_idxs):
if len(t) > max_tokens:
num_to_crop = len(t) - max_tokens
new_tokens.append(t[-max_tokens:]) # take the last max_tokens tokens
new_start_idxs.append(s - num_to_crop) # shift the indices down
new_end_idxs.append(e - num_to_crop)
assert s - num_to_crop >= 0, "this should never happen right?"
assert e - num_to_crop >= 0, "this should never happen right?"
else:
new_tokens.append(t) # keep unchanged
new_start_idxs.append(s)
new_end_idxs.append(e)
tokens, start_idxs, end_idxs = new_tokens, new_start_idxs, new_end_idxs
# Stack up all the sequences into a batch
pad_token_id = tokenizer.get_bos_token_id() # use BOS as pad token is ok
input_ids = stack_sequences(tokens, pad_token_id)
input_ids = input_ids.to(device)
# Forward the model, get the autoregressive loss and argmax prediction at each token
losses, predictions = forward_model(model, input_ids)
# See if the losses/predictions come out correctly
if task_type == 'language_modeling':
# language modeling task is currently always batch size 1
si = start_idxs[0]
ei = end_idxs[0]
# predictions[i] predict input_ids[i+1] autoregressively
predicted_tokens = predictions[0, si-1:ei-1]
actual_tokens = input_ids[0, si:ei]
is_correct = torch.all(predicted_tokens == actual_tokens).item()
elif task_type in ['multiple_choice', 'schema']:
# For MC/schema: find the option with lowest average loss
mean_losses = [losses[i, si-1:ei-1].mean().item()
for i, (si, ei) in enumerate(zip(start_idxs, end_idxs))]
pred_idx = mean_losses.index(min(mean_losses))
is_correct = pred_idx == item['gold']
else:
raise ValueError(f"Unsupported task type: {task_type}")
return is_correct
def evaluate_task(model, tokenizer, data, device, task_meta):
rank = dist.get_rank() if dist.is_initialized() else 0
world_size = dist.get_world_size() if dist.is_initialized() else 1
correct = torch.zeros(len(data), dtype=torch.float32, device=device)
# stride the examples to each rank
for idx in range(rank, len(data), world_size):
is_correct = evaluate_example(idx, model, tokenizer, data, device, task_meta)
correct[idx] = float(is_correct)
# sync results across all the processes if running distributed
if world_size > 1:
dist.barrier()
dist.all_reduce(correct, op=dist.ReduceOp.SUM)
# compute the mean
mean_correct = correct.mean().item()
return mean_correct | --- +++ @@ -1,3 +1,10 @@+"""
+Functions for evaluating the CORE metric, as described in the DCLM paper.
+https://arxiv.org/abs/2406.11794
+
+TODOs:
+- All tasks ~match except for squad. We get 31% reference is 37%. Figure out why.
+"""
import random
from jinja2 import Template
@@ -8,6 +15,7 @@ # Prompt rendering utilities
def render_prompts_mc(item, continuation_delimiter, fewshot_examples=None):
+ """Render complete prompts for a multiple choice question"""
template_str = """
{%- for example in fewshot_examples -%}
{{ example.query }}{{ continuation_delimiter }}{{ example.choices[example.gold] }}
@@ -26,6 +34,7 @@
def render_prompts_schema(item, continuation_delimiter, fewshot_examples=None):
+ """Render complete prompts for a schema question"""
template_str = """
{%- for example in fewshot_examples -%}
{{ example.context_options[example.gold] }}{{ continuation_delimiter }}{{ example.continuation }}
@@ -45,6 +54,11 @@
def render_prompts_lm(item, continuation_delimiter, fewshot_examples=None):
+ """
+ Render complete prompt for a language modeling task.
+ Notice that we manually trim the context in the template,
+ which in some datasets seems to have trailing whitespace (which we don't want).
+ """
template_str = """
{%- for example in fewshot_examples -%}
{{ example.context | trim }}{{ continuation_delimiter }}{{ example.continuation }}
@@ -70,6 +84,10 @@
def find_common_length(token_sequences, direction='left'):
+ """
+ Find the length of the common prefix or suffix across token sequences
+ - direction: 'left' for prefix, 'right' for suffix
+ """
min_len = min(len(seq) for seq in token_sequences)
indices = {
'left': range(min_len),
@@ -84,6 +102,7 @@
def stack_sequences(tokens, pad_token_id):
+ """Stack up a list of token sequences, pad to longest on the right"""
bsz, seq_len = len(tokens), max(len(x) for x in tokens)
input_ids = torch.full((bsz, seq_len), pad_token_id, dtype=torch.long)
for i, x in enumerate(tokens):
@@ -124,6 +143,10 @@
@torch.no_grad()
def forward_model(model, input_ids):
+ """
+ Take BxT tensor of token ids, return BxT tensor of losses and argmax predictions.
+ The last column of losses is set to nan because we don't have autoregressive targets there.
+ """
batch_size, seq_len = input_ids.size()
outputs = model(input_ids)
# Roll the tensor to the left by one position to get the (autoregressive) target ids
@@ -143,6 +166,7 @@
@torch.no_grad()
def evaluate_example(idx, model, tokenizer, data, device, task_meta):
+ """Evaluate a single example, return True if correct, False otherwise"""
item = data[idx]
task_type = task_meta['task_type']
num_fewshot = task_meta['num_fewshot']
@@ -218,6 +242,10 @@
def evaluate_task(model, tokenizer, data, device, task_meta):
+ """
+ This function is responsible for evaluating one task across many examples.
+ It also handles dispatch to all processes if the script is run with torchrun.
+ """
rank = dist.get_rank() if dist.is_initialized() else 0
world_size = dist.get_world_size() if dist.is_initialized() else 1
correct = torch.zeros(len(data), dtype=torch.float32, device=device)
@@ -231,4 +259,4 @@ dist.all_reduce(correct, op=dist.ReduceOp.SUM)
# compute the mean
mean_correct = correct.mean().item()
- return mean_correct+ return mean_correct
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/core_eval.py |
Help me document legacy Python code | from typing import Dict, List, Optional
from mem0.configs.llms.base import BaseLlmConfig
from mem0.llms.base import LLMBase
try:
from langchain.chat_models.base import BaseChatModel
from langchain_core.messages import AIMessage
except ImportError:
raise ImportError("langchain is not installed. Please install it using `pip install langchain`")
class LangchainLLM(LLMBase):
def __init__(self, config: Optional[BaseLlmConfig] = None):
super().__init__(config)
if self.config.model is None:
raise ValueError("`model` parameter is required")
if not isinstance(self.config.model, BaseChatModel):
raise ValueError("`model` must be an instance of BaseChatModel")
self.langchain_model = self.config.model
def _parse_response(self, response: AIMessage, tools: Optional[List[Dict]]):
if not tools:
return response.content
processed_response = {
"content": response.content,
"tool_calls": [],
}
for tool_call in response.tool_calls:
processed_response["tool_calls"].append(
{
"name": tool_call["name"],
"arguments": tool_call["args"],
}
)
return processed_response
def generate_response(
self,
messages: List[Dict[str, str]],
response_format=None,
tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
# Convert the messages to LangChain's tuple format
langchain_messages = []
for message in messages:
role = message["role"]
content = message["content"]
if role == "system":
langchain_messages.append(("system", content))
elif role == "user":
langchain_messages.append(("human", content))
elif role == "assistant":
langchain_messages.append(("ai", content))
if not langchain_messages:
raise ValueError("No valid messages found in the messages list")
langchain_model = self.langchain_model
if tools:
langchain_model = langchain_model.bind_tools(tools=tools, tool_choice=tool_choice)
response: AIMessage = langchain_model.invoke(langchain_messages)
return self._parse_response(response, tools) | --- +++ @@ -23,6 +23,16 @@ self.langchain_model = self.config.model
def _parse_response(self, response: AIMessage, tools: Optional[List[Dict]]):
+ """
+ Process the response based on whether tools are used or not.
+
+ Args:
+ response: AI Message.
+ tools: The list of tools provided in the request.
+
+ Returns:
+ str or dict: The processed response.
+ """
if not tools:
return response.content
@@ -48,6 +58,18 @@ tools: Optional[List[Dict]] = None,
tool_choice: str = "auto",
):
+ """
+ Generate a response based on the given messages using langchain_community.
+
+ Args:
+ messages (list): List of message dicts containing 'role' and 'content'.
+ response_format (str or object, optional): Format of the response. Not used in Langchain.
+ tools (list, optional): List of tools that the model can call.
+ tool_choice (str, optional): Tool choice method.
+
+ Returns:
+ str: The generated response.
+ """
# Convert the messages to LangChain's tuple format
langchain_messages = []
for message in messages:
@@ -69,4 +91,4 @@ langchain_model = langchain_model.bind_tools(tools=tools, tool_choice=tool_choice)
response: AIMessage = langchain_model.invoke(langchain_messages)
- return self._parse_response(response, tools)+ return self._parse_response(response, tools)
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/llms/langchain.py |
Document all public functions with docstrings |
import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile
from dataclasses import dataclass
from typing import Optional
# -----------------------------------------------------------------------------
@dataclass
class ExecutionResult:
success: bool
stdout: str
stderr: str
error: Optional[str] = None
timeout: bool = False
memory_exceeded: bool = False
def __repr__(self):
parts = []
parts.append(f"ExecutionResult(success={self.success}")
if self.timeout:
parts.append(", timeout=True")
if self.memory_exceeded:
parts.append(", memory_exceeded=True")
if self.error:
parts.append(f", error={self.error!r}")
if self.stdout:
parts.append(f", stdout={self.stdout!r}")
if self.stderr:
parts.append(f", stderr={self.stderr!r}")
parts.append(")")
return "".join(parts)
@contextlib.contextmanager
def time_limit(seconds: float):
def signal_handler(signum, frame):
raise TimeoutException("Timed out!")
signal.setitimer(signal.ITIMER_REAL, seconds)
signal.signal(signal.SIGALRM, signal_handler)
try:
yield
finally:
signal.setitimer(signal.ITIMER_REAL, 0)
@contextlib.contextmanager
def capture_io():
stdout_capture = io.StringIO()
stderr_capture = io.StringIO()
stdin_block = WriteOnlyStringIO()
with contextlib.redirect_stdout(stdout_capture):
with contextlib.redirect_stderr(stderr_capture):
with redirect_stdin(stdin_block):
yield stdout_capture, stderr_capture
@contextlib.contextmanager
def create_tempdir():
with tempfile.TemporaryDirectory() as dirname:
with chdir(dirname):
yield dirname
class TimeoutException(Exception):
pass
class WriteOnlyStringIO(io.StringIO):
def read(self, *args, **kwargs):
raise IOError
def readline(self, *args, **kwargs):
raise IOError
def readlines(self, *args, **kwargs):
raise IOError
def readable(self, *args, **kwargs):
return False
class redirect_stdin(contextlib._RedirectStream): # type: ignore
_stream = "stdin"
@contextlib.contextmanager
def chdir(root):
if root == ".":
yield
return
cwd = os.getcwd()
os.chdir(root)
try:
yield
finally:
os.chdir(cwd)
def reliability_guard(maximum_memory_bytes: Optional[int] = None):
if platform.uname().system != "Darwin":
# These resource limit calls seem to fail on macOS (Darwin), skip?
import resource
resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes))
resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes))
resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes))
faulthandler.disable()
import builtins
builtins.exit = None
builtins.quit = None
import os
os.environ["OMP_NUM_THREADS"] = "1"
os.kill = None
os.system = None
os.putenv = None
os.remove = None
os.removedirs = None
os.rmdir = None
os.fchdir = None
os.setuid = None
os.fork = None
os.forkpty = None
os.killpg = None
os.rename = None
os.renames = None
os.truncate = None
os.replace = None
os.unlink = None
os.fchmod = None
os.fchown = None
os.chmod = None
os.chown = None
os.chroot = None
os.fchdir = None
os.lchflags = None
os.lchmod = None
os.lchown = None
os.getcwd = None
os.chdir = None
import shutil
shutil.rmtree = None
shutil.move = None
shutil.chown = None
import subprocess
subprocess.Popen = None # type: ignore
__builtins__["help"] = None
import sys
sys.modules["ipdb"] = None
sys.modules["joblib"] = None
sys.modules["resource"] = None
sys.modules["psutil"] = None
sys.modules["tkinter"] = None
def _unsafe_execute(code: str, timeout: float, maximum_memory_bytes: Optional[int], result_dict):
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
import os
import shutil
rmtree = shutil.rmtree
rmdir = os.rmdir
chdir = os.chdir
unlink = os.unlink
# Disable functionalities that can make destructive changes to the test.
reliability_guard(maximum_memory_bytes=maximum_memory_bytes)
# Default to failure
result_dict.update({
"success": False,
"stdout": "",
"stderr": "",
"timeout": False,
"memory_exceeded": False,
"error": None,
})
try:
exec_globals = {}
with capture_io() as (stdout_capture, stderr_capture):
with time_limit(timeout):
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network. For more
# information on how OpenAI sandboxes its code, see the accompanying paper.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
exec(code, exec_globals)
result_dict.update({
"success": True,
"stdout": stdout_capture.getvalue(),
"stderr": stderr_capture.getvalue(),
})
except TimeoutException:
result_dict.update({
"timeout": True,
"error": "Execution timed out",
})
except MemoryError as e:
result_dict.update({
"memory_exceeded": True,
"error": f"Memory limit exceeded: {e}",
})
except BaseException as e:
result_dict.update({
"error": f"{type(e).__name__}: {e}",
})
# Needed for cleaning up.
shutil.rmtree = rmtree
os.rmdir = rmdir
os.chdir = chdir
os.unlink = unlink
def execute_code(
code: str,
timeout: float = 5.0, # 5 seconds default
maximum_memory_bytes: Optional[int] = 256 * 1024 * 1024, # 256MB default
) -> ExecutionResult:
manager = multiprocessing.Manager()
result_dict = manager.dict()
p = multiprocessing.Process(
target=_unsafe_execute,
args=(code, timeout, maximum_memory_bytes, result_dict)
)
p.start()
p.join(timeout=timeout + 1)
if p.is_alive():
p.kill()
return ExecutionResult(
success=False,
stdout="",
stderr="",
error="Execution timed out (process killed)",
timeout=True,
memory_exceeded=False,
)
if not result_dict:
return ExecutionResult(
success=False,
stdout="",
stderr="",
error="Execution failed (no result returned)",
timeout=True,
memory_exceeded=False,
)
return ExecutionResult(
success=result_dict["success"],
stdout=result_dict["stdout"],
stderr=result_dict["stderr"],
error=result_dict["error"],
timeout=result_dict["timeout"],
memory_exceeded=result_dict["memory_exceeded"],
)
| --- +++ @@ -1,3 +1,25 @@+"""
+Sandboxed execution utilities for running Python code that comes out of an LLM.
+Adapted from OpenAI HumanEval code:
+https://github.com/openai/human-eval/blob/master/human_eval/execution.py
+
+What is covered:
+- Each execution runs in its own process (can be killed if it hangs or crashes)
+- Execution is limited by a timeout to stop infinite loops
+- Memory limits are enforced by default (256MB)
+- stdout and stderr are captured and returned
+- Code runs in a temporary directory that is deleted afterwards
+- Dangerous functions are disabled (examples: os.system, os.kill, shutil.rmtree, subprocess.Popen)
+
+What is not covered:
+- Not a true security sandbox
+- Network access is not blocked (e.g. sockets could be opened)
+- Python's dynamic features (e.g. ctypes) could bypass restrictions
+- No kernel-level isolation (no seccomp, no containers, no virtualization)
+
+Overall this sandbox is good for evaluation of generated code and protects against
+accidental destructive behavior, but it is not safe against malicious adversarial code.
+"""
import contextlib
import faulthandler
@@ -14,6 +36,7 @@
@dataclass
class ExecutionResult:
+ """Result of executing Python code in a sandbox."""
success: bool
stdout: str
stderr: str
@@ -53,6 +76,7 @@
@contextlib.contextmanager
def capture_io():
+ """Capture stdout and stderr, and disable stdin."""
stdout_capture = io.StringIO()
stderr_capture = io.StringIO()
stdin_block = WriteOnlyStringIO()
@@ -74,6 +98,7 @@
class WriteOnlyStringIO(io.StringIO):
+ """StringIO that throws an exception when it's read from"""
def read(self, *args, **kwargs):
raise IOError
@@ -85,6 +110,7 @@ raise IOError
def readable(self, *args, **kwargs):
+ """Returns True if the IO object can be read."""
return False
@@ -106,6 +132,17 @@
def reliability_guard(maximum_memory_bytes: Optional[int] = None):
+ """
+ This disables various destructive functions and prevents the generated code
+ from interfering with the test (e.g. fork bomb, killing other processes,
+ removing filesystem files, etc.)
+
+ WARNING
+ This function is NOT a security sandbox. Untrusted code, including, model-
+ generated code, should not be blindly executed outside of one. See the
+ Codex paper for more information about OpenAI's code sandbox, and proceed
+ with caution.
+ """
if platform.uname().system != "Darwin":
# These resource limit calls seem to fail on macOS (Darwin), skip?
@@ -175,6 +212,7 @@
def _unsafe_execute(code: str, timeout: float, maximum_memory_bytes: Optional[int], result_dict):
+ """Execute code in a subprocess with safety guards. Results are written to result_dict."""
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
@@ -250,6 +288,24 @@ timeout: float = 5.0, # 5 seconds default
maximum_memory_bytes: Optional[int] = 256 * 1024 * 1024, # 256MB default
) -> ExecutionResult:
+ """
+ Execute Python code in a sandboxed environment.
+
+ Args:
+ code: Python code to execute as a string
+ timeout: Maximum execution time in seconds (default: 5.0)
+ maximum_memory_bytes: Memory limit in bytes (default: 256MB, None to disable)
+
+ Returns:
+ ExecutionResult with success status, stdout/stderr, and error information
+
+ Example:
+ >>> result = execute_code("print('hello world')")
+ >>> result.success
+ True
+ >>> result.stdout
+ 'hello world\\n'
+ """
manager = multiprocessing.Manager()
result_dict = manager.dict()
@@ -290,3 +346,4 @@ timeout=result_dict["timeout"],
memory_exceeded=result_dict["memory_exceeded"],
)
+
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/execution.py |
Add docstrings including usage examples | import math
import torch
import torch.distributed as dist
@torch.no_grad()
def evaluate_bpb(model, batches, steps, token_bytes):
# record the losses
total_nats = torch.tensor(0.0, dtype=torch.float32, device=model.get_device())
total_bytes = torch.tensor(0, dtype=torch.int64, device=model.get_device())
batch_iter = iter(batches)
for _ in range(steps):
x, y = next(batch_iter)
loss2d = model(x, y, loss_reduction='none') # (B, T)
loss2d = loss2d.view(-1) # flatten
y = y.view(-1) # flatten
if (y.int() < 0).any(): # mps does not currently have kernel for < 0 for int64, only int32
# slightly more complex code path if some target tokens are ignore_index (e.g. -1)
# any target token < 0 is to be ignored: do NOT index token_bytes with negatives
valid = y >= 0
y_safe = torch.where(valid, y, torch.zeros_like(y))
# map valid targets to their byte length; ignored targets contribute 0 bytes
num_bytes2d = torch.where(
valid,
token_bytes[y_safe],
torch.zeros_like(y, dtype=token_bytes.dtype)
)
total_nats += (loss2d * (num_bytes2d > 0)).sum()
total_bytes += num_bytes2d.sum()
else:
# fast path: no ignored targets, safe to index directly
num_bytes2d = token_bytes[y]
total_nats += (loss2d * (num_bytes2d > 0)).sum()
total_bytes += num_bytes2d.sum()
# sum reduce across all ranks
world_size = dist.get_world_size() if dist.is_initialized() else 1
if world_size > 1:
dist.all_reduce(total_nats, op=dist.ReduceOp.SUM)
dist.all_reduce(total_bytes, op=dist.ReduceOp.SUM)
# move both to cpu, calculate bpb and return
total_nats = total_nats.item()
total_bytes = total_bytes.item()
if total_bytes == 0:
return float('inf')
bpb = total_nats / (math.log(2) * total_bytes)
return bpb | --- +++ @@ -1,9 +1,29 @@+"""
+A number of functions that help with evaluating a base model.
+"""
import math
import torch
import torch.distributed as dist
@torch.no_grad()
def evaluate_bpb(model, batches, steps, token_bytes):
+ """
+ Instead of the naive 'mean loss', this function returns the bits per byte (bpb),
+ which is a tokenization vocab size-independent metric, meaning you are still comparing
+ apples:apples if you change the vocab size. The way this works is that instead of just
+ calculating the average loss as usual, you calculate the sum loss, and independently
+ also the sum bytes (of all the target tokens), and divide. This normalizes the loss by
+ the number of bytes that the target tokens represent.
+
+ The added complexity is so that:
+ 1) All "normal" tokens are normalized by the length of the token in bytes
+ 2) No special tokens (e.g. <|bos|>) are included in the metric - they are masked out.
+ 3) No actively masked tokens (using ignore_index of e.g. -1) are included in the metric.
+
+ In addition to evaluate_loss, we need the token_bytes tensor:
+ It is a 1D tensor of shape (vocab_size,), indicating the number of bytes for
+ each token id, or 0 if the token is to not be counted (e.g. special tokens).
+ """
# record the losses
total_nats = torch.tensor(0.0, dtype=torch.float32, device=model.get_device())
total_bytes = torch.tensor(0, dtype=torch.int64, device=model.get_device())
@@ -42,4 +62,4 @@ if total_bytes == 0:
return float('inf')
bpb = total_nats / (math.log(2) * total_bytes)
- return bpb+ return bpb
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/loss_eval.py |
Add docstrings that explain logic | import requests
import json
import os
import copy
import random
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
from nanochat.common import get_base_dir
load_dotenv()
api_key = os.environ["OPENROUTER_API_KEY"]
url = "https://openrouter.ai/api/v1/chat/completions"
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
# Load the comprehensive knowledge base
knowledge_path = os.path.join(os.path.dirname(__file__), "..", "knowledge", "self_knowledge.md")
knowledge = open(knowledge_path, "r", encoding="utf-8").read().strip()
assert os.path.exists(knowledge_path), f"Knowledge base file not found: {knowledge_path}"
# for right now I am not committing the self_knowledge file to repo. You can use README.md instead
# of it, or you can generate one by asking an LLM to make one based on the README/files.
# This whole file is just a helpful demonstration of the kind of thing you'd run.
# =============================================================================
# DIVERSITY DIMENSIONS
# =============================================================================
# Topics/questions the conversation should explore
# Group by category for balanced sampling
topics = {
"identity": [
"who/what is nanochat",
"who created nanochat and why",
"what does the name 'nanochat' mean",
"is nanochat open source, what license",
"where can I find the code",
"how can I contribute to nanochat",
],
"architecture": [
"basic architecture overview (transformer, layers, parameters)",
"what is RoPE and why use it",
"explain RMSNorm vs LayerNorm",
"what is Flash Attention and why it matters",
"sliding window attention pattern",
"value embeddings - what are they",
"per-layer residual scalars",
"ReLU squared activation",
"logit softcapping",
"QK normalization",
],
"training": [
"how much did it cost to train nanochat",
"how long does training take",
"what hardware is needed",
"what data was nanochat trained on",
"what is the Muon optimizer",
"explain the split optimizer design",
"what is the depth parameter and scaling",
"what is the CORE metric",
],
"capabilities": [
"what can nanochat do",
"can nanochat write code",
"can nanochat do math (calculator tool)",
"can nanochat help with writing",
"what languages does nanochat speak",
"how good is nanochat at reasoning",
],
"limitations": [
"what can nanochat NOT do",
"why does nanochat work best in English",
"does nanochat have internet access",
"what is nanochat's context length limit",
"can nanochat remember previous conversations",
"can nanochat make mistakes / hallucinate",
"is nanochat good for production use",
],
"comparisons": [
"how does nanochat compare to GPT-2",
"how does nanochat compare to ChatGPT/GPT-4",
"how does nanochat compare to Claude",
"why is training 600x cheaper than GPT-2",
"what's special about nanochat vs other open models",
],
"history": [
"the GPT-2 training cost in 2019",
"how AI training costs have dropped over time",
"relationship to modded-nanogpt project",
"what optimizations worked vs didn't work",
"the journey of building nanochat",
],
"technical_deep_dive": [
"explain the tokenizer (BPE, vocab size)",
"how does distributed training work (ZeRO)",
"explain the dataloader and BOS alignment",
"what is compute-optimal training",
"how does the calculator tool work",
"explain inference with KV cache",
],
"philosophical": [
"is nanochat conscious / does it have feelings",
"what happens when nanochat is wrong",
"can nanochat learn from this conversation",
"why make AI training accessible",
"the future of open source AI",
],
}
# User personas - different people ask questions differently
personas = [
"curious beginner who knows nothing about AI or machine learning",
"ML researcher or engineer who wants technical depth and specifics",
"developer considering contributing to the nanochat project",
"skeptic who doubts open source can compete with big AI labs",
"computer science student learning about transformers and LLMs",
"someone comparing nanochat to ChatGPT, Claude, or other assistants",
"journalist or writer covering AI democratization and open source",
"hobbyist who just wants to chat and learn casually",
"someone interested in the cost and economics of AI training",
"teacher or educator wanting to use nanochat for teaching",
"entrepreneur exploring if nanochat fits their use case",
"someone who just discovered the project and wants the basics",
]
# Conversation dynamics - shape and flow
dynamics = [
"short 2-turn Q&A: user asks one question, gets a complete answer",
"medium 4-turn: user asks, gets answer, asks followup for clarification",
"deep 6-turn technical discussion: progressively deeper questions",
"skeptical arc: user starts doubtful, assistant addresses concerns honestly",
"learning journey: user starts basic, assistant builds up complexity gradually",
"comparison-focused: user keeps comparing to other models, assistant explains differences",
"limitation exploration: user probes what nanochat cannot do, assistant is honest",
"casual friendly chat that naturally touches on identity and capabilities",
"troubleshooting: user has misconceptions, assistant gently corrects them",
"enthusiastic: user is excited about the project, assistant shares that energy appropriately",
]
# First messages - greetings and openers
# Categorized for balanced sampling
first_messages = {
"simple_greetings": [
"hi", "Hi!", "hello", "Hello?", "hey there", "Hey!", "yo", "Yo!",
"Good morning", "Good evening!", "Howdy", "sup", "What's up?",
"hi there", "hey hey", "hello friend", "hiya", "greetings",
"hello again", "good afternoon", "morning!", "evening!",
],
"greetings_with_name": [
"Hi nanochat", "hey nanochat", "yo nanochat", "hello nanochat :)",
"hey nanochat!", "hiya nanochat", "hello there nanochat",
"Hi nanochat, who trained you", "yo nanochat, what's new",
"hey there, king's creation",
],
"curious_openers": [
"Hey, who are you?", "Hi, what is this?", "Hey, are you a chatbot?",
"Hello! Who am I talking to?", "hi! what do you do?",
"hi! who made you", "hey! are you alive", "hiya! what are you",
"hello! tell me about yourself", "hi, what's your name",
"yo, what is this", "hi! who built you", "hello! are you open source",
"hey, what version are you", "hi! what's your story",
"hey, what's nanochat", "hello! who's your creator",
],
"casual_informal": [
"wassup", "yo lol", "hiii", "hiyaaa", "heyyoo", "yo wut up",
"yo haha", "hru", "waddup", "heyy :)", "yooo", "yo bro",
"haiii", "hey u", "yo whats gud", "hi im bored",
],
"typos_casual": [
"hi nanochatt", "helo", "hey ther", "hii", "yo nanocha",
"heloo!", "hi, whos this", "hay", "helloo??", "hi nanocat",
"helo nanochat", "hai!", "helllo nano", "yo nanochta",
],
"caps_enthusiastic": [
"HI", "HELLOOO", "YO!!!", "HEY", "SUP", "WASSUP", "HEY!!!",
"HELLO??", "HI THERE!!", "HEYOOOO", "HIII", "YOOOO", "HELLO!!!",
],
"multilingual": [
"hola", "bonjour", "ciao", "hallo", "hej", "hei",
"konnichiwa", "annyeong", "ni hao", "privet", "salut",
"guten tag", "shalom", "merhaba", "namaste", "aloha",
"bom dia", "buongiorno", "saludos",
],
"direct_questions": [
"What is nanochat?", "Who made you?", "Are you GPT?",
"How do you compare to ChatGPT?", "Can you help me code?",
"What can you do?", "Are you open source?", "How were you trained?",
"What's your context limit?", "Can you browse the internet?",
],
}
# =============================================================================
# PROMPT TEMPLATE
# =============================================================================
prompt_template = r"""
I want to generate synthetic training data for an AI assistant called "nanochat" to teach it about its own identity, capabilities, and limitations.
## KNOWLEDGE BASE
Here is comprehensive information about nanochat that you should use as the authoritative source of facts:
---
{knowledge}
---
## YOUR TASK
Generate a realistic multi-turn conversation between a User and the nanochat Assistant.
**Topic to explore:** {topic}
**User persona:** {persona}
**Conversation dynamic:** {dynamic}
## STYLE GUIDELINES
1. **Plain ASCII only** - No emojis, special characters, or unicode. Just plain text.
2. **Natural conversation** - Make it feel like a real chat, not a Q&A exam.
3. **Accurate facts** - Use ONLY information from the knowledge base above. Don't make up statistics or features.
4. **Appropriate depth** - Match the technical level to the user persona.
5. **Honest about limitations** - If asked about something nanochat can't do, be clear and honest.
6. **Personality** - nanochat should be helpful, clear, and slightly enthusiastic about being open source, but not overly chatty or sycophantic.
## FIRST MESSAGE EXAMPLES
Here are some example first messages from users (for style inspiration):
{first_message_examples}
## SPECIAL CASES
- **Non-English first message:** If the user writes in another language, nanochat should briefly acknowledge it can understand but works best in English, then continue helpfully.
- **Misconceptions:** If the user has wrong assumptions (e.g., "you're made by OpenAI"), gently correct them.
- **Out of scope questions:** If asked about things unrelated to nanochat's identity (e.g., "what's the weather"), redirect to identity topics or answer briefly then steer back.
## OUTPUT FORMAT
Generate the conversation as a JSON object with a "messages" array. Each message has "role" (user/assistant) and "content". Start with a user message.
""".strip()
# =============================================================================
# API CONFIGURATION
# =============================================================================
response_format = {
"type": "json_schema",
"json_schema": {
"name": "conversation",
"strict": True,
"schema": {
"type": "object",
"properties": {
"messages": {
"type": "array",
"description": "Conversation messages alternating user/assistant, starting with user",
"items": {
"type": "object",
"properties": {
"role": {
"type": "string",
"description": "Either 'user' or 'assistant'"
},
"content": {
"type": "string",
"description": "The message content"
}
},
"required": ["role", "content"],
"additionalProperties": False
}
}
},
"required": ["messages"],
"additionalProperties": False
}
}
}
base_payload = {
"model": "google/gemini-3-flash-preview",
"stream": False,
"response_format": response_format,
"temperature": 1.0,
}
# =============================================================================
# GENERATION LOGIC
# =============================================================================
def sample_diversity_elements(rng):
# Sample topic: first pick a category, then a topic within it
category = rng.choice(list(topics.keys()))
topic = rng.choice(topics[category])
# Sample persona
persona = rng.choice(personas)
# Sample dynamic
dynamic = rng.choice(dynamics)
# Sample first message examples: pick from multiple categories
first_msg_samples = []
categories = rng.sample(list(first_messages.keys()), min(3, len(first_messages)))
for cat in categories:
first_msg_samples.append(rng.choice(first_messages[cat]))
return {
"topic": topic,
"persona": persona,
"dynamic": dynamic,
"first_message_examples": "\n".join(f"- {msg}" for msg in first_msg_samples),
}
def generate_conversation(idx: int):
# Use idx as seed for reproducibility
rng = random.Random(idx)
# Sample diversity elements
elements = sample_diversity_elements(rng)
# Build the prompt
prompt = prompt_template.format(
knowledge=knowledge,
topic=elements["topic"],
persona=elements["persona"],
dynamic=elements["dynamic"],
first_message_examples=elements["first_message_examples"],
)
# Make API request
payload = copy.deepcopy(base_payload)
payload['messages'] = [{"role": "user", "content": prompt}]
response = requests.post(url, headers=headers, json=payload)
result = response.json()
if 'error' in result:
raise Exception(f"API error: {result['error']}")
content = result['choices'][0]['message']['content']
conversation_data = json.loads(content)
messages = conversation_data['messages']
# Return messages along with metadata for debugging
return {
"messages": messages,
"metadata": {
"topic": elements["topic"],
"persona": elements["persona"],
"dynamic": elements["dynamic"],
}
}
def validate_conversation(messages):
if len(messages) < 2:
raise ValueError(f"Conversation too short: {len(messages)} messages")
for i, message in enumerate(messages):
expected_role = "user" if i % 2 == 0 else "assistant"
if message['role'] != expected_role:
raise ValueError(f"Message {i} has role '{message['role']}', expected '{expected_role}'")
if not message['content'].strip():
raise ValueError(f"Message {i} has empty content")
return True
# =============================================================================
# MAIN
# =============================================================================
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Generate synthetic conversation data")
parser.add_argument("--num", type=int, default=1000, help="Number of conversations to generate")
parser.add_argument("--workers", type=int, default=4, help="Number of parallel workers")
parser.add_argument("--output", type=str, default=None, help="Output file path")
parser.add_argument("--append", action="store_true", help="Append to existing file instead of overwriting")
parser.add_argument("--save-metadata", action="store_true", help="Save metadata alongside messages")
args = parser.parse_args()
# Set output file
if args.output:
output_file = args.output
else:
output_file = os.path.join(get_base_dir(), "identity_conversations.jsonl")
# Handle file creation/clearing
if not args.append and os.path.exists(output_file):
os.remove(output_file)
print(f"Output file: {output_file}")
print(f"Generating {args.num} conversations with {args.workers} workers...")
print(f"Topic categories: {list(topics.keys())}")
print(f"Personas: {len(personas)}")
print(f"Dynamics: {len(dynamics)}")
print()
completed_count = 0
error_count = 0
with ThreadPoolExecutor(max_workers=args.workers) as executor:
# Submit all tasks
futures = {executor.submit(generate_conversation, idx): idx
for idx in range(args.num)}
# Process results as they complete
for future in as_completed(futures):
idx = futures[future]
try:
result = future.result()
messages = result["messages"]
metadata = result["metadata"]
# Validate
validate_conversation(messages)
# Write to file
with open(output_file, 'a') as f:
if args.save_metadata:
f.write(json.dumps({"messages": messages, "metadata": metadata}) + '\n')
else:
f.write(json.dumps(messages) + '\n')
completed_count += 1
topic_short = metadata["topic"][:40] + "..." if len(metadata["topic"]) > 40 else metadata["topic"]
print(f"[{completed_count}/{args.num}] Topic: {topic_short}")
except Exception as e:
error_count += 1
print(f"[ERROR] idx={idx}: {e}")
print()
print(f"Done! Saved {completed_count} conversations to {output_file}")
if error_count > 0:
print(f"Encountered {error_count} errors during generation") | --- +++ @@ -1,3 +1,23 @@+"""
+Synthetic data generation for teaching nanochat about its identity and capabilities.
+
+This script uses the OpenRouter API to generate diverse multi-turn conversations
+between a user and nanochat. The conversations are saved to a .jsonl file for use
+in supervised finetuning (SFT) via the CustomJSON task.
+
+Key design principles for high-quality synthetic data:
+1. DIVERSITY CONTROL is critical - we inject entropy at multiple levels:
+ - Topic/question categories (what the conversation is about)
+ - User personas (who is asking)
+ - Conversation dynamics (shape and flow)
+ - First message style (greeting variation)
+2. Comprehensive knowledge base - we provide detailed facts so the LLM
+ generating conversations has accurate information to draw from.
+3. Structured outputs - we use JSON schema to guarantee valid format.
+
+NOTE: You need OPENROUTER_API_KEY set in .env or as an environment variable.
+NOTE: For more details see: https://github.com/karpathy/nanochat/discussions/139
+"""
import requests
import json
import os
@@ -290,6 +310,7 @@ # =============================================================================
def sample_diversity_elements(rng):
+ """Sample one element from each diversity dimension."""
# Sample topic: first pick a category, then a topic within it
category = rng.choice(list(topics.keys()))
topic = rng.choice(topics[category])
@@ -315,6 +336,10 @@
def generate_conversation(idx: int):
+ """
+ Generate a single conversation using the OpenRouter API.
+ Returns a list of message dicts with 'role' and 'content' keys.
+ """
# Use idx as seed for reproducibility
rng = random.Random(idx)
@@ -356,6 +381,7 @@
def validate_conversation(messages):
+ """Validate conversation structure."""
if len(messages) < 2:
raise ValueError(f"Conversation too short: {len(messages)} messages")
@@ -439,4 +465,4 @@ print()
print(f"Done! Saved {completed_count} conversations to {output_file}")
if error_count > 0:
- print(f"Encountered {error_count} errors during generation")+ print(f"Encountered {error_count} errors during generation")
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/dev/gen_synthetic_data.py |
Add missing documentation to my Python functions | import logging
from mem0.memory.utils import format_entities, sanitize_relationship_for_cypher
try:
from langchain_memgraph.graphs.memgraph import Memgraph
except ImportError:
raise ImportError("langchain_memgraph is not installed. Please install it using pip install langchain-memgraph")
try:
from rank_bm25 import BM25Okapi
except ImportError:
raise ImportError("rank_bm25 is not installed. Please install it using pip install rank-bm25")
from mem0.graphs.tools import (
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
DELETE_MEMORY_TOOL_GRAPH,
EXTRACT_ENTITIES_STRUCT_TOOL,
EXTRACT_ENTITIES_TOOL,
RELATIONS_STRUCT_TOOL,
RELATIONS_TOOL,
)
from mem0.graphs.utils import EXTRACT_RELATIONS_PROMPT, get_delete_messages
from mem0.utils.factory import EmbedderFactory, LlmFactory
logger = logging.getLogger(__name__)
class MemoryGraph:
def __init__(self, config):
self.config = config
self.graph = Memgraph(
self.config.graph_store.config.url,
self.config.graph_store.config.username,
self.config.graph_store.config.password,
)
self.embedding_model = EmbedderFactory.create(
self.config.embedder.provider,
self.config.embedder.config,
{"enable_embeddings": True},
)
# Default to openai if no specific provider is configured
self.llm_provider = "openai"
if self.config.llm and self.config.llm.provider:
self.llm_provider = self.config.llm.provider
if self.config.graph_store and self.config.graph_store.llm and self.config.graph_store.llm.provider:
self.llm_provider = self.config.graph_store.llm.provider
# Get LLM config with proper null checks
llm_config = None
if self.config.graph_store and self.config.graph_store.llm and hasattr(self.config.graph_store.llm, "config"):
llm_config = self.config.graph_store.llm.config
elif hasattr(self.config.llm, "config"):
llm_config = self.config.llm.config
self.llm = LlmFactory.create(self.llm_provider, llm_config)
self.user_id = None
# Use threshold from graph_store config, default to 0.7 for backward compatibility
self.threshold = self.config.graph_store.threshold if hasattr(self.config.graph_store, 'threshold') else 0.7
# Setup Memgraph:
# 1. Create vector index (created Entity label on all nodes)
# 2. Create label property index for performance optimizations
embedding_dims = self.config.embedder.config["embedding_dims"]
index_info = self._fetch_existing_indexes()
# Create vector index if not exists
if not self._vector_index_exists(index_info, "memzero"):
self.graph.query(
f"CREATE VECTOR INDEX memzero ON :Entity(embedding) WITH CONFIG {{'dimension': {embedding_dims}, 'capacity': 1000, 'metric': 'cos'}};"
)
# Create label+property index if not exists
if not self._label_property_index_exists(index_info, "Entity", "user_id"):
self.graph.query("CREATE INDEX ON :Entity(user_id);")
# Create label index if not exists
if not self._label_index_exists(index_info, "Entity"):
self.graph.query("CREATE INDEX ON :Entity;")
def add(self, data, filters):
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
to_be_deleted = self._get_delete_entities_from_search_output(search_output, data, filters)
# TODO: Batch queries with APOC plugin
# TODO: Add more filter support
deleted_entities = self._delete_entities(to_be_deleted, filters)
added_entities = self._add_entities(to_be_added, filters, entity_type_map)
return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=100):
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
if not search_output:
return []
search_outputs_sequence = [
[item["source"], item["relationship"], item["destination"]] for item in search_output
]
bm25 = BM25Okapi(search_outputs_sequence)
tokenized_query = query.split(" ")
reranked_results = bm25.get_top_n(tokenized_query, search_outputs_sequence, n=5)
search_results = []
for item in reranked_results:
search_results.append({"source": item[0], "relationship": item[1], "destination": item[2]})
logger.info(f"Returned {len(search_results)} search results")
return search_results
def delete_all(self, filters):
if filters.get("agent_id"):
cypher = """
MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})
DETACH DELETE n
"""
params = {"user_id": filters["user_id"], "agent_id": filters["agent_id"]}
else:
cypher = """
MATCH (n:Entity {user_id: $user_id})
DETACH DELETE n
"""
params = {"user_id": filters["user_id"]}
self.graph.query(cypher, params=params)
def get_all(self, filters, limit=100):
# Build query based on whether agent_id is provided
if filters.get("agent_id"):
query = """
MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})-[r]->(m:Entity {user_id: $user_id, agent_id: $agent_id})
RETURN n.name AS source, type(r) AS relationship, m.name AS target
LIMIT $limit
"""
params = {"user_id": filters["user_id"], "agent_id": filters["agent_id"], "limit": limit}
else:
query = """
MATCH (n:Entity {user_id: $user_id})-[r]->(m:Entity {user_id: $user_id})
RETURN n.name AS source, type(r) AS relationship, m.name AS target
LIMIT $limit
"""
params = {"user_id": filters["user_id"], "limit": limit}
results = self.graph.query(query, params=params)
final_results = []
for result in results:
final_results.append(
{
"source": result["source"],
"relationship": result["relationship"],
"target": result["target"],
}
)
logger.info(f"Retrieved {len(final_results)} relationships")
return final_results
def _retrieve_nodes_from_data(self, data, filters):
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
search_results = self.llm.generate_response(
messages=[
{
"role": "system",
"content": f"You are a smart assistant who understands entities and their types in a given text. If user message contains self reference such as 'I', 'me', 'my' etc. then use {filters['user_id']} as the source entity. Extract all the entities from the text. ***DO NOT*** answer the question itself if the given text is a question.",
},
{"role": "user", "content": data},
],
tools=_tools,
)
entity_type_map = {}
try:
for tool_call in search_results["tool_calls"]:
if tool_call["name"] != "extract_entities":
continue
for item in tool_call.get("arguments", {}).get("entities", []):
if "entity" in item and "entity_type" in item:
entity_type_map[item["entity"]] = item["entity_type"]
except Exception as e:
logger.exception(
f"Error in search tool: {e}, llm_provider={self.llm_provider}, search_results={search_results}"
)
entity_type_map = {k.lower().replace(" ", "_"): v.lower().replace(" ", "_") for k, v in entity_type_map.items()}
logger.debug(f"Entity type map: {entity_type_map}\n search_results={search_results}")
return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
if self.config.graph_store.custom_prompt:
messages = [
{
"role": "system",
"content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]).replace(
"CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}"
),
},
{"role": "user", "content": data},
]
else:
messages = [
{
"role": "system",
"content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]),
},
{
"role": "user",
"content": f"List of entities: {list(entity_type_map.keys())}. \n\nText: {data}",
},
]
_tools = [RELATIONS_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [RELATIONS_STRUCT_TOOL]
extracted_entities = self.llm.generate_response(
messages=messages,
tools=_tools,
)
entities = []
if extracted_entities and extracted_entities.get("tool_calls"):
entities = extracted_entities["tool_calls"][0].get("arguments", {}).get("entities", [])
entities = self._remove_spaces_from_entities(entities)
logger.debug(f"Extracted entities: {entities}")
return entities
def _search_graph_db(self, node_list, filters, limit=100):
result_relations = []
for node in node_list:
n_embedding = self.embedding_model.embed(node)
# Build query based on whether agent_id is provided
if filters.get("agent_id"):
cypher_query = """
CALL vector_search.search("memzero", $limit, $n_embedding)
YIELD distance, node, similarity
WITH node AS n, similarity
WHERE n:Entity AND n.user_id = $user_id AND n.agent_id = $agent_id AND n.embedding IS NOT NULL AND similarity >= $threshold
MATCH (n)-[r]->(m:Entity)
RETURN n.name AS source, id(n) AS source_id, type(r) AS relationship, id(r) AS relation_id, m.name AS destination, id(m) AS destination_id, similarity
UNION
CALL vector_search.search("memzero", $limit, $n_embedding)
YIELD distance, node, similarity
WITH node AS n, similarity
WHERE n:Entity AND n.user_id = $user_id AND n.agent_id = $agent_id AND n.embedding IS NOT NULL AND similarity >= $threshold
MATCH (m:Entity)-[r]->(n)
RETURN m.name AS source, id(m) AS source_id, type(r) AS relationship, id(r) AS relation_id, n.name AS destination, id(n) AS destination_id, similarity
ORDER BY similarity DESC
LIMIT $limit;
"""
params = {
"n_embedding": n_embedding,
"threshold": self.threshold,
"user_id": filters["user_id"],
"agent_id": filters["agent_id"],
"limit": limit,
}
else:
cypher_query = """
CALL vector_search.search("memzero", $limit, $n_embedding)
YIELD distance, node, similarity
WITH node AS n, similarity
WHERE n:Entity AND n.user_id = $user_id AND n.embedding IS NOT NULL AND similarity >= $threshold
MATCH (n)-[r]->(m:Entity)
RETURN n.name AS source, id(n) AS source_id, type(r) AS relationship, id(r) AS relation_id, m.name AS destination, id(m) AS destination_id, similarity
UNION
CALL vector_search.search("memzero", $limit, $n_embedding)
YIELD distance, node, similarity
WITH node AS n, similarity
WHERE n:Entity AND n.user_id = $user_id AND n.embedding IS NOT NULL AND similarity >= $threshold
MATCH (m:Entity)-[r]->(n)
RETURN m.name AS source, id(m) AS source_id, type(r) AS relationship, id(r) AS relation_id, n.name AS destination, id(n) AS destination_id, similarity
ORDER BY similarity DESC
LIMIT $limit;
"""
params = {
"n_embedding": n_embedding,
"threshold": self.threshold,
"user_id": filters["user_id"],
"limit": limit,
}
ans = self.graph.query(cypher_query, params=params)
result_relations.extend(ans)
return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
search_output_string = format_entities(search_output)
system_prompt, user_prompt = get_delete_messages(search_output_string, data, filters["user_id"])
_tools = [DELETE_MEMORY_TOOL_GRAPH]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [
DELETE_MEMORY_STRUCT_TOOL_GRAPH,
]
memory_updates = self.llm.generate_response(
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
tools=_tools,
)
to_be_deleted = []
for item in memory_updates["tool_calls"]:
if item["name"] == "delete_graph_memory":
to_be_deleted.append(item["arguments"])
# in case if it is not in the correct format
to_be_deleted = self._remove_spaces_from_entities(to_be_deleted)
logger.debug(f"Deleted relationships: {to_be_deleted}")
return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
results = []
for item in to_be_deleted:
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# Build the agent filter for the query
agent_filter = ""
params = {
"source_name": source,
"dest_name": destination,
"user_id": user_id,
}
if agent_id:
agent_filter = "AND n.agent_id = $agent_id AND m.agent_id = $agent_id"
params["agent_id"] = agent_id
# Delete the specific relationship between nodes
cypher = f"""
MATCH (n:Entity {{name: $source_name, user_id: $user_id}})
-[r:{relationship}]->
(m:Entity {{name: $dest_name, user_id: $user_id}})
WHERE 1=1 {agent_filter}
DELETE r
RETURN
n.name AS source,
m.name AS target,
type(r) AS relationship
"""
result = self.graph.query(cypher, params=params)
results.append(result)
return results
# added Entity label to all nodes for vector search to work
def _add_entities(self, to_be_added, filters, entity_type_map):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
results = []
for item in to_be_added:
# entities
source = item["source"]
destination = item["destination"]
relationship = item["relationship"]
# types
source_type = entity_type_map.get(source, "__User__")
destination_type = entity_type_map.get(destination, "__User__")
# embeddings
source_embedding = self.embedding_model.embed(source)
dest_embedding = self.embedding_model.embed(destination)
# search for the nodes with the closest embeddings
source_node_search_result = self._search_source_node(source_embedding, filters, threshold=self.threshold)
destination_node_search_result = self._search_destination_node(dest_embedding, filters, threshold=self.threshold)
# Prepare agent_id for node creation
agent_id_clause = ""
if agent_id:
agent_id_clause = ", agent_id: $agent_id"
# TODO: Create a cypher query and common params for all the cases
if not destination_node_search_result and source_node_search_result:
cypher = f"""
MATCH (source:Entity)
WHERE id(source) = $source_id
MERGE (destination:{destination_type}:Entity {{name: $destination_name, user_id: $user_id{agent_id_clause}}})
ON CREATE SET
destination.created = timestamp(),
destination.embedding = $destination_embedding,
destination:Entity
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp()
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"source_id": source_node_search_result[0]["id(source_candidate)"],
"destination_name": destination,
"destination_embedding": dest_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
elif destination_node_search_result and not source_node_search_result:
cypher = f"""
MATCH (destination:Entity)
WHERE id(destination) = $destination_id
MERGE (source:{source_type}:Entity {{name: $source_name, user_id: $user_id{agent_id_clause}}})
ON CREATE SET
source.created = timestamp(),
source.embedding = $source_embedding,
source:Entity
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created = timestamp()
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"destination_id": destination_node_search_result[0]["id(destination_candidate)"],
"source_name": source,
"source_embedding": source_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
elif source_node_search_result and destination_node_search_result:
cypher = f"""
MATCH (source:Entity)
WHERE id(source) = $source_id
MATCH (destination:Entity)
WHERE id(destination) = $destination_id
MERGE (source)-[r:{relationship}]->(destination)
ON CREATE SET
r.created_at = timestamp(),
r.updated_at = timestamp()
RETURN source.name AS source, type(r) AS relationship, destination.name AS target
"""
params = {
"source_id": source_node_search_result[0]["id(source_candidate)"],
"destination_id": destination_node_search_result[0]["id(destination_candidate)"],
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
else:
cypher = f"""
MERGE (n:{source_type}:Entity {{name: $source_name, user_id: $user_id{agent_id_clause}}})
ON CREATE SET n.created = timestamp(), n.embedding = $source_embedding, n:Entity
ON MATCH SET n.embedding = $source_embedding
MERGE (m:{destination_type}:Entity {{name: $dest_name, user_id: $user_id{agent_id_clause}}})
ON CREATE SET m.created = timestamp(), m.embedding = $dest_embedding, m:Entity
ON MATCH SET m.embedding = $dest_embedding
MERGE (n)-[rel:{relationship}]->(m)
ON CREATE SET rel.created = timestamp()
RETURN n.name AS source, type(rel) AS relationship, m.name AS target
"""
params = {
"source_name": source,
"dest_name": destination,
"source_embedding": source_embedding,
"dest_embedding": dest_embedding,
"user_id": user_id,
}
if agent_id:
params["agent_id"] = agent_id
result = self.graph.query(cypher, params=params)
results.append(result)
return results
def _remove_spaces_from_entities(self, entity_list):
for item in entity_list:
item["source"] = item["source"].lower().replace(" ", "_")
# Use the sanitization function for relationships to handle special characters
item["relationship"] = sanitize_relationship_for_cypher(item["relationship"].lower().replace(" ", "_"))
item["destination"] = item["destination"].lower().replace(" ", "_")
return entity_list
def _search_source_node(self, source_embedding, filters, threshold=0.9):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
if agent_id:
cypher = """
CALL vector_search.search("memzero", 1, $source_embedding)
YIELD distance, node, similarity
WITH node AS source_candidate, similarity
WHERE source_candidate.user_id = $user_id
AND source_candidate.agent_id = $agent_id
AND similarity >= $threshold
RETURN id(source_candidate);
"""
params = {
"source_embedding": source_embedding,
"user_id": user_id,
"agent_id": agent_id,
"threshold": threshold,
}
else:
cypher = """
CALL vector_search.search("memzero", 1, $source_embedding)
YIELD distance, node, similarity
WITH node AS source_candidate, similarity
WHERE source_candidate.user_id = $user_id
AND similarity >= $threshold
RETURN id(source_candidate);
"""
params = {
"source_embedding": source_embedding,
"user_id": user_id,
"threshold": threshold,
}
result = self.graph.query(cypher, params=params)
return result
def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
if agent_id:
cypher = """
CALL vector_search.search("memzero", 1, $destination_embedding)
YIELD distance, node, similarity
WITH node AS destination_candidate, similarity
WHERE node.user_id = $user_id
AND node.agent_id = $agent_id
AND similarity >= $threshold
RETURN id(destination_candidate);
"""
params = {
"destination_embedding": destination_embedding,
"user_id": user_id,
"agent_id": agent_id,
"threshold": threshold,
}
else:
cypher = """
CALL vector_search.search("memzero", 1, $destination_embedding)
YIELD distance, node, similarity
WITH node AS destination_candidate, similarity
WHERE node.user_id = $user_id
AND similarity >= $threshold
RETURN id(destination_candidate);
"""
params = {
"destination_embedding": destination_embedding,
"user_id": user_id,
"threshold": threshold,
}
result = self.graph.query(cypher, params=params)
return result
def _vector_index_exists(self, index_info, index_name):
vector_indexes = index_info.get("vector_index_exists", [])
# Check for index by name regardless of version-specific format differences
return any(
idx.get("index_name") == index_name or
idx.get("index name") == index_name or
idx.get("name") == index_name
for idx in vector_indexes
)
def _label_property_index_exists(self, index_info, label, property_name):
indexes = index_info.get("index_exists", [])
return any(
(idx.get("index type") == "label+property" or idx.get("index_type") == "label+property") and
(idx.get("label") == label) and
(idx.get("property") == property_name or property_name in str(idx.get("properties", "")))
for idx in indexes
)
def _label_index_exists(self, index_info, label):
indexes = index_info.get("index_exists", [])
return any(
(idx.get("index type") == "label" or idx.get("index_type") == "label") and
(idx.get("label") == label)
for idx in indexes
)
def _fetch_existing_indexes(self):
try:
index_exists = list(self.graph.query("SHOW INDEX INFO;"))
vector_index_exists = list(self.graph.query("SHOW VECTOR INDEX INFO;"))
return {"index_exists": index_exists, "vector_index_exists": vector_index_exists}
except Exception as e:
logger.warning(f"Error fetching indexes: {e}. Returning empty index info.")
return {"index_exists": [], "vector_index_exists": []} | --- +++ @@ -79,6 +79,13 @@ self.graph.query("CREATE INDEX ON :Entity;")
def add(self, data, filters):
+ """
+ Adds data to the graph.
+
+ Args:
+ data (str): The data to add to the graph.
+ filters (dict): A dictionary containing filters to be applied during the addition.
+ """
entity_type_map = self._retrieve_nodes_from_data(data, filters)
to_be_added = self._establish_nodes_relations_from_data(data, filters, entity_type_map)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -92,6 +99,19 @@ return {"deleted_entities": deleted_entities, "added_entities": added_entities}
def search(self, query, filters, limit=100):
+ """
+ Search for memories and related graph data.
+
+ Args:
+ query (str): Query to search for.
+ filters (dict): A dictionary containing filters to be applied during the search.
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+
+ Returns:
+ dict: A dictionary containing:
+ - "contexts": List of search results from the base data store.
+ - "entities": List of related graph data based on the query.
+ """
entity_type_map = self._retrieve_nodes_from_data(query, filters)
search_output = self._search_graph_db(node_list=list(entity_type_map.keys()), filters=filters)
@@ -115,6 +135,7 @@ return search_results
def delete_all(self, filters):
+ """Delete all nodes and relationships for a user or specific agent."""
if filters.get("agent_id"):
cypher = """
MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})
@@ -130,6 +151,19 @@ self.graph.query(cypher, params=params)
def get_all(self, filters, limit=100):
+ """
+ Retrieves all nodes and relationships from the graph database based on optional filtering criteria.
+
+ Args:
+ filters (dict): A dictionary containing filters to be applied during the retrieval.
+ Supports 'user_id' (required) and 'agent_id' (optional).
+ limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
+ Returns:
+ list: A list of dictionaries, each containing:
+ - 'source': The source node name.
+ - 'relationship': The relationship type.
+ - 'target': The target node name.
+ """
# Build query based on whether agent_id is provided
if filters.get("agent_id"):
query = """
@@ -163,6 +197,7 @@ return final_results
def _retrieve_nodes_from_data(self, data, filters):
+ """Extracts all the entities mentioned in the query."""
_tools = [EXTRACT_ENTITIES_TOOL]
if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
_tools = [EXTRACT_ENTITIES_STRUCT_TOOL]
@@ -196,6 +231,7 @@ return entity_type_map
def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
+ """Eshtablish relations among the extracted nodes."""
if self.config.graph_store.custom_prompt:
messages = [
{
@@ -236,6 +272,7 @@ return entities
def _search_graph_db(self, node_list, filters, limit=100):
+ """Search similar nodes among and their respective incoming and outgoing relations."""
result_relations = []
for node in node_list:
@@ -298,6 +335,7 @@ return result_relations
def _get_delete_entities_from_search_output(self, search_output, data, filters):
+ """Get the entities to be deleted from the search output."""
search_output_string = format_entities(search_output)
system_prompt, user_prompt = get_delete_messages(search_output_string, data, filters["user_id"])
@@ -324,6 +362,7 @@ return to_be_deleted
def _delete_entities(self, to_be_deleted, filters):
+ """Delete the entities from the graph."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
results = []
@@ -365,6 +404,7 @@
# added Entity label to all nodes for vector search to work
def _add_entities(self, to_be_added, filters, entity_type_map):
+ """Add the new entities to the graph. Merge the nodes if they already exist."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
results = []
@@ -496,6 +536,7 @@ return entity_list
def _search_source_node(self, source_embedding, filters, threshold=0.9):
+ """Search for source nodes with similar embeddings."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
@@ -534,6 +575,7 @@ return result
def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
+ """Search for destination nodes with similar embeddings."""
user_id = filters["user_id"]
agent_id = filters.get("agent_id", None)
@@ -573,6 +615,16 @@
def _vector_index_exists(self, index_info, index_name):
+ """
+ Check if a vector index exists, compatible with both Memgraph versions.
+
+ Args:
+ index_info (dict): Index information from _fetch_existing_indexes
+ index_name (str): Name of the index to check
+
+ Returns:
+ bool: True if index exists, False otherwise
+ """
vector_indexes = index_info.get("vector_index_exists", [])
# Check for index by name regardless of version-specific format differences
@@ -584,6 +636,17 @@ )
def _label_property_index_exists(self, index_info, label, property_name):
+ """
+ Check if a label+property index exists, compatible with both versions.
+
+ Args:
+ index_info (dict): Index information from _fetch_existing_indexes
+ label (str): Label name
+ property_name (str): Property name
+
+ Returns:
+ bool: True if index exists, False otherwise
+ """
indexes = index_info.get("index_exists", [])
return any(
@@ -594,6 +657,16 @@ )
def _label_index_exists(self, index_info, label):
+ """
+ Check if a label index exists, compatible with both versions.
+
+ Args:
+ index_info (dict): Index information from _fetch_existing_indexes
+ label (str): Label name
+
+ Returns:
+ bool: True if index exists, False otherwise
+ """
indexes = index_info.get("index_exists", [])
return any(
@@ -603,10 +676,16 @@ )
def _fetch_existing_indexes(self):
+ """
+ Retrieves information about existing indexes and vector indexes in the Memgraph database.
+
+ Returns:
+ dict: A dictionary containing lists of existing indexes and vector indexes.
+ """
try:
index_exists = list(self.graph.query("SHOW INDEX INFO;"))
vector_index_exists = list(self.graph.query("SHOW VECTOR INDEX INFO;"))
return {"index_exists": index_exists, "vector_index_exists": vector_index_exists}
except Exception as e:
logger.warning(f"Error fetching indexes: {e}. Returning empty index info.")
- return {"index_exists": [], "vector_index_exists": []}+ return {"index_exists": [], "vector_index_exists": []}
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/memory/memgraph_memory.py |
Add docstrings to meet PEP guidelines |
import torch
import torch.distributed as dist
from torch import Tensor
# -----------------------------------------------------------------------------
"""
Good old AdamW optimizer, fused kernel.
https://arxiv.org/abs/1711.05101
"""
@torch.compile(dynamic=False, fullgraph=True)
def adamw_step_fused(
p: Tensor, # (32768, 768) - parameter tensor
grad: Tensor, # (32768, 768) - gradient, same shape as p
exp_avg: Tensor, # (32768, 768) - first moment, same shape as p
exp_avg_sq: Tensor, # (32768, 768) - second moment, same shape as p
step_t: Tensor, # () - 0-D CPU tensor, step count
lr_t: Tensor, # () - 0-D CPU tensor, learning rate
beta1_t: Tensor, # () - 0-D CPU tensor, beta1
beta2_t: Tensor, # () - 0-D CPU tensor, beta2
eps_t: Tensor, # () - 0-D CPU tensor, epsilon
wd_t: Tensor, # () - 0-D CPU tensor, weight decay
) -> None:
# Weight decay (decoupled, applied before the update)
p.mul_(1 - lr_t * wd_t)
# Update running averages (lerp_ is cleaner and fuses well)
exp_avg.lerp_(grad, 1 - beta1_t)
exp_avg_sq.lerp_(grad.square(), 1 - beta2_t)
# Bias corrections
bias1 = 1 - beta1_t ** step_t
bias2 = 1 - beta2_t ** step_t
# Compute update and apply
denom = (exp_avg_sq / bias2).sqrt() + eps_t
step_size = lr_t / bias1
p.add_(exp_avg / denom, alpha=-step_size)
# -----------------------------------------------------------------------------
"""
Muon optimizer adapted and simplified from modded-nanogpt.
https://github.com/KellerJordan/modded-nanogpt
Background:
Newton-Schulz iteration to compute the zeroth power / orthogonalization of G. We opt to use a
quintic iteration whose coefficients are selected to maximize the slope at zero. For the purpose
of minimizing steps, it turns out to be empirically effective to keep increasing the slope at
zero even beyond the point where the iteration no longer converges all the way to one everywhere
on the interval. This iteration therefore does not produce UV^T but rather something like US'V^T
where S' is diagonal with S_{ii}' ~ Uniform(0.5, 1.5), which turns out not to hurt model
performance at all relative to UV^T, where USV^T = G is the SVD.
Here, an alternative to Newton-Schulz iteration with potentially better convergence properties:
Polar Express Sign Method for orthogonalization.
https://arxiv.org/pdf/2505.16932
by Noah Amsel, David Persson, Christopher Musco, Robert M. Gower.
NorMuon variance reduction: per-neuron/column adaptive learning rate that normalizes
update scales after orthogonalization (Muon's output has non-uniform scales across neurons).
https://arxiv.org/pdf/2510.05491
Some of the changes in nanochat implementation:
- Uses a simpler, more general approach to parameter grouping and stacking
- Uses a single fused kernel for the momentum -> polar_express -> variance_reduction -> update step
- Makes no assumptions about model architecture (e.g. that attention weights are fused into QKVO format)
"""
# Coefficients for Polar Express (computed for num_iters=5, safety_factor=2e-2, cushion=2)
# From https://arxiv.org/pdf/2505.16932
polar_express_coeffs = [
(8.156554524902461, -22.48329292557795, 15.878769915207462),
(4.042929935166739, -2.808917465908714, 0.5000178451051316),
(3.8916678022926607, -2.772484153217685, 0.5060648178503393),
(3.285753657755655, -2.3681294933425376, 0.46449024233003106),
(2.3465413258596377, -1.7097828382687081, 0.42323551169305323),
]
@torch.compile(dynamic=False, fullgraph=True)
def muon_step_fused(
stacked_grads: Tensor, # (12, 768, 3072) - stacked gradients
stacked_params: Tensor, # (12, 768, 3072) - stacked parameters
momentum_buffer: Tensor, # (12, 768, 3072) - first moment buffer
second_momentum_buffer: Tensor, # (12, 768, 1) or (12, 1, 3072) - factored second moment
momentum_t: Tensor, # () - 0-D CPU tensor, momentum coefficient
lr_t: Tensor, # () - 0-D CPU tensor, learning rate
wd_t: Tensor, # () - 0-D CPU tensor, weight decay
beta2_t: Tensor, # () - 0-D CPU tensor, beta2 for second moment
ns_steps: int, # 5 - number of Newton-Schulz/Polar Express iterations
red_dim: int, # -1 or -2 - reduction dimension for variance
) -> None:
# Nesterov momentum
momentum = momentum_t.to(stacked_grads.dtype)
momentum_buffer.lerp_(stacked_grads, 1 - momentum)
g = stacked_grads.lerp_(momentum_buffer, momentum)
# Polar express
X = g.bfloat16()
X = X / (X.norm(dim=(-2, -1), keepdim=True) * 1.01 + 1e-6)
if g.size(-2) > g.size(-1): # Tall matrix
for a, b, c in polar_express_coeffs[:ns_steps]:
A = X.mT @ X
B = b * A + c * (A @ A)
X = a * X + X @ B
else: # Wide matrix (original math)
for a, b, c in polar_express_coeffs[:ns_steps]:
A = X @ X.mT
B = b * A + c * (A @ A)
X = a * X + B @ X
g = X
# Variance reduction
beta2 = beta2_t.to(g.dtype)
v_mean = g.float().square().mean(dim=red_dim, keepdim=True)
red_dim_size = g.size(red_dim)
v_norm_sq = v_mean.sum(dim=(-2, -1), keepdim=True) * red_dim_size
v_norm = v_norm_sq.sqrt()
second_momentum_buffer.lerp_(v_mean.to(dtype=second_momentum_buffer.dtype), 1 - beta2)
step_size = second_momentum_buffer.clamp_min(1e-10).rsqrt()
scaled_sq_sum = (v_mean * red_dim_size) * step_size.float().square()
v_norm_new = scaled_sq_sum.sum(dim=(-2, -1), keepdim=True).sqrt()
final_scale = step_size * (v_norm / v_norm_new.clamp_min(1e-10))
g = g * final_scale.to(g.dtype)
# Cautious weight decay + parameter update
lr = lr_t.to(g.dtype)
wd = wd_t.to(g.dtype)
mask = (g * stacked_params) >= 0
stacked_params.sub_(lr * g + lr * wd * stacked_params * mask)
# -----------------------------------------------------------------------------
# Single GPU version of the MuonAdamW optimizer.
# Used mostly for reference, debugging and testing.
class MuonAdamW(torch.optim.Optimizer):
def __init__(self, param_groups: list[dict]):
super().__init__(param_groups, defaults={})
# 0-D CPU tensors to avoid torch.compile recompilation when values change
# AdamW tensors
self._adamw_step_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_lr_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_beta1_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_eps_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_wd_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
# Muon tensors
self._muon_momentum_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_lr_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_wd_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
def _step_adamw(self, group: dict) -> None:
for p in group['params']:
if p.grad is None:
continue
grad = p.grad
state = self.state[p]
# State init
if not state:
state['step'] = 0
state['exp_avg'] = torch.zeros_like(p)
state['exp_avg_sq'] = torch.zeros_like(p)
exp_avg = state['exp_avg']
exp_avg_sq = state['exp_avg_sq']
state['step'] += 1
# Fill 0-D tensors with current values
self._adamw_step_t.fill_(state['step'])
self._adamw_lr_t.fill_(group['lr'])
self._adamw_beta1_t.fill_(group['betas'][0])
self._adamw_beta2_t.fill_(group['betas'][1])
self._adamw_eps_t.fill_(group['eps'])
self._adamw_wd_t.fill_(group['weight_decay'])
# Fused update: weight_decay -> momentum -> bias_correction -> param_update
adamw_step_fused(
p, grad, exp_avg, exp_avg_sq,
self._adamw_step_t, self._adamw_lr_t, self._adamw_beta1_t,
self._adamw_beta2_t, self._adamw_eps_t, self._adamw_wd_t,
)
def _step_muon(self, group: dict) -> None:
params: list[Tensor] = group['params']
if not params:
return
# Get or create group-level buffers (stored in first param's state for convenience)
p = params[0]
state = self.state[p]
num_params = len(params)
shape, device, dtype = p.shape, p.device, p.dtype
# Momentum for every individual parameter
if "momentum_buffer" not in state:
state["momentum_buffer"] = torch.zeros(num_params, *shape, dtype=dtype, device=device)
momentum_buffer = state["momentum_buffer"]
# Second momentum buffer is factored, either per-row or per-column
if "second_momentum_buffer" not in state:
state_shape = (num_params, shape[-2], 1) if shape[-2] >= shape[-1] else (num_params, 1, shape[-1])
state["second_momentum_buffer"] = torch.zeros(state_shape, dtype=dtype, device=device)
second_momentum_buffer = state["second_momentum_buffer"]
red_dim = -1 if shape[-2] >= shape[-1] else -2
# Stack grads and params (NOTE: this assumes all params have the same shape)
stacked_grads = torch.stack([p.grad for p in params])
stacked_params = torch.stack(params)
# Fill all the 0-D tensors with current values
self._muon_momentum_t.fill_(group["momentum"])
self._muon_beta2_t.fill_(group["beta2"] if group["beta2"] is not None else 0.0)
self._muon_lr_t.fill_(group["lr"] * max(1.0, shape[-2] / shape[-1])**0.5)
self._muon_wd_t.fill_(group["weight_decay"])
# Single fused kernel: momentum -> polar_express -> variance_reduction -> update
muon_step_fused(
stacked_grads,
stacked_params,
momentum_buffer,
second_momentum_buffer,
self._muon_momentum_t,
self._muon_lr_t,
self._muon_wd_t,
self._muon_beta2_t,
group["ns_steps"],
red_dim,
)
# Copy back to original params
torch._foreach_copy_(params, list(stacked_params.unbind(0)))
@torch.no_grad()
def step(self):
for group in self.param_groups:
if group['kind'] == 'adamw':
self._step_adamw(group)
elif group['kind'] == 'muon':
self._step_muon(group)
else:
raise ValueError(f"Unknown optimizer kind: {group['kind']}")
# -----------------------------------------------------------------------------
# Distributed version of the MuonAdamW optimizer.
# Used for training on multiple GPUs.
class DistMuonAdamW(torch.optim.Optimizer):
def __init__(self, param_groups: list[dict]):
super().__init__(param_groups, defaults={})
# 0-D CPU tensors to avoid torch.compile recompilation when values change
self._adamw_step_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_lr_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_beta1_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_eps_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._adamw_wd_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_momentum_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_lr_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_wd_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
self._muon_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
def _reduce_adamw(self, group: dict, world_size: int) -> dict:
param_infos = {}
for p in group['params']:
grad = p.grad
if p.numel() < 1024:
# Small params: all_reduce (no scatter/gather needed)
future = dist.all_reduce(grad, op=dist.ReduceOp.AVG, async_op=True).get_future()
param_infos[p] = dict(future=future, grad_slice=grad, is_small=True)
else:
# Large params: reduce_scatter
assert grad.shape[0] % world_size == 0, f"AdamW reduce_scatter requires shape[0] ({grad.shape[0]}) divisible by world_size ({world_size})"
rank_size = grad.shape[0] // world_size
grad_slice = torch.empty_like(grad[:rank_size])
future = dist.reduce_scatter_tensor(grad_slice, grad, op=dist.ReduceOp.AVG, async_op=True).get_future()
param_infos[p] = dict(future=future, grad_slice=grad_slice, is_small=False)
return dict(param_infos=param_infos)
def _reduce_muon(self, group: dict, world_size: int) -> dict:
params = group['params']
chunk_size = (len(params) + world_size - 1) // world_size
padded_num_params = chunk_size * world_size
p = params[0]
shape, device, dtype = p.shape, p.device, p.dtype
# Stack grads and zero-pad to padded_num_params
grad_stack = torch.stack([p.grad for p in params])
stacked_grads = torch.empty(padded_num_params, *shape, dtype=dtype, device=device)
stacked_grads[:len(params)].copy_(grad_stack)
if len(params) < padded_num_params:
stacked_grads[len(params):].zero_()
# Reduce_scatter to get this rank's chunk
grad_chunk = torch.empty(chunk_size, *shape, dtype=dtype, device=device)
future = dist.reduce_scatter_tensor(grad_chunk, stacked_grads, op=dist.ReduceOp.AVG, async_op=True).get_future()
return dict(future=future, grad_chunk=grad_chunk, stacked_grads=stacked_grads, chunk_size=chunk_size)
def _compute_adamw(self, group: dict, info: dict, gather_list: list, rank: int, world_size: int) -> None:
param_infos = info['param_infos']
for p in group['params']:
pinfo = param_infos[p]
pinfo['future'].wait()
grad_slice = pinfo['grad_slice']
state = self.state[p]
# For small params, operate on full param; for large, operate on slice
if pinfo['is_small']:
p_slice = p
else:
rank_size = p.shape[0] // world_size
p_slice = p[rank * rank_size:(rank + 1) * rank_size]
# State init
if not state:
state['step'] = 0
state['exp_avg'] = torch.zeros_like(p_slice)
state['exp_avg_sq'] = torch.zeros_like(p_slice)
state['step'] += 1
# Fill 0-D tensors and run fused kernel
self._adamw_step_t.fill_(state['step'])
self._adamw_lr_t.fill_(group['lr'])
self._adamw_beta1_t.fill_(group['betas'][0])
self._adamw_beta2_t.fill_(group['betas'][1])
self._adamw_eps_t.fill_(group['eps'])
self._adamw_wd_t.fill_(group['weight_decay'])
adamw_step_fused(
p_slice, grad_slice, state['exp_avg'], state['exp_avg_sq'],
self._adamw_step_t, self._adamw_lr_t, self._adamw_beta1_t,
self._adamw_beta2_t, self._adamw_eps_t, self._adamw_wd_t,
)
# Large params need all_gather
if not pinfo['is_small']:
future = dist.all_gather_into_tensor(p, p_slice, async_op=True).get_future()
gather_list.append(dict(future=future, params=None))
def _compute_muon(self, group: dict, info: dict, gather_list: list, rank: int) -> None:
info['future'].wait()
params = group['params']
chunk_size = info['chunk_size']
grad_chunk = info['grad_chunk']
p = params[0]
shape, device, dtype = p.shape, p.device, p.dtype
# How many params does this rank own?
start_idx = rank * chunk_size
num_owned = min(chunk_size, max(0, len(params) - start_idx))
# Get or create group-level state
state = self.state[p]
if "momentum_buffer" not in state:
state["momentum_buffer"] = torch.zeros(chunk_size, *shape, dtype=dtype, device=device)
if "second_momentum_buffer" not in state:
state_shape = (chunk_size, shape[-2], 1) if shape[-2] >= shape[-1] else (chunk_size, 1, shape[-1])
state["second_momentum_buffer"] = torch.zeros(state_shape, dtype=dtype, device=device)
red_dim = -1 if shape[-2] >= shape[-1] else -2
# Build output buffer for all_gather
updated_params = torch.empty(chunk_size, *shape, dtype=dtype, device=device)
if num_owned > 0:
owned_params = [params[start_idx + i] for i in range(num_owned)]
stacked_owned = torch.stack(owned_params)
# Fill 0-D tensors and run fused kernel
self._muon_momentum_t.fill_(group["momentum"])
self._muon_beta2_t.fill_(group["beta2"])
self._muon_lr_t.fill_(group["lr"] * max(1.0, shape[-2] / shape[-1])**0.5)
self._muon_wd_t.fill_(group["weight_decay"])
muon_step_fused(
grad_chunk[:num_owned], stacked_owned,
state["momentum_buffer"][:num_owned], state["second_momentum_buffer"][:num_owned],
self._muon_momentum_t, self._muon_lr_t, self._muon_wd_t, self._muon_beta2_t,
group["ns_steps"], red_dim,
)
updated_params[:num_owned].copy_(stacked_owned)
if num_owned < chunk_size:
updated_params[num_owned:].zero_()
# Reuse stacked_grads buffer for all_gather output
stacked_params = info["stacked_grads"]
future = dist.all_gather_into_tensor(stacked_params, updated_params, async_op=True).get_future()
gather_list.append(dict(future=future, stacked_params=stacked_params, params=params))
def _finish_gathers(self, gather_list: list) -> None:
for info in gather_list:
info["future"].wait()
if info["params"] is not None:
# Muon: copy from stacked buffer back to individual params
torch._foreach_copy_(info["params"], list(info["stacked_params"][:len(info["params"])].unbind(0)))
@torch.no_grad()
def step(self):
rank = dist.get_rank()
world_size = dist.get_world_size()
# Phase 1: launch all async reduce ops
reduce_infos: list[dict] = []
for group in self.param_groups:
if group['kind'] == 'adamw':
reduce_infos.append(self._reduce_adamw(group, world_size))
elif group['kind'] == 'muon':
reduce_infos.append(self._reduce_muon(group, world_size))
else:
raise ValueError(f"Unknown optimizer kind: {group['kind']}")
# Phase 2: wait for reduces, compute updates, launch gathers
gather_list: list[dict] = []
for group, info in zip(self.param_groups, reduce_infos):
if group['kind'] == 'adamw':
self._compute_adamw(group, info, gather_list, rank, world_size)
elif group['kind'] == 'muon':
self._compute_muon(group, info, gather_list, rank)
else:
raise ValueError(f"Unknown optimizer kind: {group['kind']}")
# Phase 3: wait for gathers, copy back
self._finish_gathers(gather_list) | --- +++ @@ -1,3 +1,11 @@+"""
+A nice and efficient mixed AdamW/Muon Combined Optimizer.
+Usually the embeddings and scalars go into AdamW, and the matrix parameters go into Muon.
+Two versions are provided (MuonAdamW, DistMuonAdamW), for single GPU and distributed.
+
+Addapted from: https://github.com/KellerJordan/modded-nanogpt
+Further contributions from @karpathy and @chrisjmccormick.
+"""
import torch
import torch.distributed as dist
@@ -22,6 +30,11 @@ eps_t: Tensor, # () - 0-D CPU tensor, epsilon
wd_t: Tensor, # () - 0-D CPU tensor, weight decay
) -> None:
+ """
+ Fused AdamW step: weight_decay -> momentum_update -> bias_correction -> param_update
+ All in one compiled graph to eliminate Python overhead between ops.
+ The 0-D CPU tensors avoid recompilation when hyperparameter values change.
+ """
# Weight decay (decoupled, applied before the update)
p.mul_(1 - lr_t * wd_t)
# Update running averages (lerp_ is cleaner and fuses well)
@@ -87,6 +100,11 @@ ns_steps: int, # 5 - number of Newton-Schulz/Polar Express iterations
red_dim: int, # -1 or -2 - reduction dimension for variance
) -> None:
+ """
+ Fused Muon step: momentum -> polar_express -> variance_reduction -> cautious_update
+ All in one compiled graph to eliminate Python overhead between ops.
+ Some of the constants are 0-D CPU tensors to avoid recompilation when values change.
+ """
# Nesterov momentum
momentum = momentum_t.to(stacked_grads.dtype)
@@ -132,6 +150,31 @@ # Used mostly for reference, debugging and testing.
class MuonAdamW(torch.optim.Optimizer):
+ """
+ Combined optimizer: Muon for 2D matrix params, AdamW for others, single GPU version.
+
+ AdamW - Fused AdamW optimizer step.
+
+ Muon - MomentUm Orthogonalized by Newton-schulz
+ https://kellerjordan.github.io/posts/muon/
+
+ Muon internally runs standard SGD-momentum, and then performs an orthogonalization post-
+ processing step, in which each 2D parameter's update is replaced with the nearest orthogonal
+ matrix. To efficiently orthogonalize each update, we use a Newton-Schulz iteration, which has
+ the advantage that it can be stably run in bfloat16 on the GPU.
+
+ Some warnings:
+ - The Muon optimizer should not be used for the embedding layer, the final fully connected layer,
+ or any {0,1}-D parameters; those should all be optimized by a standard method (e.g., AdamW).
+ - To use it with 4D convolutional filters, it works well to just flatten their last 3 dimensions.
+
+ Arguments:
+ param_groups: List of dicts, each containing:
+ - 'params': List of parameters
+ - 'kind': 'adamw' or 'muon'
+ - For AdamW groups: 'lr', 'betas', 'eps', 'weight_decay'
+ - For Muon groups: 'lr', 'momentum', 'ns_steps', 'beta2', 'weight_decay'
+ """
def __init__(self, param_groups: list[dict]):
super().__init__(param_groups, defaults={})
# 0-D CPU tensors to avoid torch.compile recompilation when values change
@@ -149,6 +192,10 @@ self._muon_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
def _step_adamw(self, group: dict) -> None:
+ """
+ AdamW update for each param in the group individually.
+ Lazy init the state, fill in all 0-D tensors, call the fused kernel.
+ """
for p in group['params']:
if p.grad is None:
continue
@@ -180,6 +227,10 @@ )
def _step_muon(self, group: dict) -> None:
+ """
+ Muon update for all params in the group (stacked for efficiency).
+ Lazy init the state, fill in all 0-D tensors, call the fused kernel.
+ """
params: list[Tensor] = group['params']
if not params:
return
@@ -244,6 +295,63 @@ # Used for training on multiple GPUs.
class DistMuonAdamW(torch.optim.Optimizer):
+ """
+ Combined distributed optimizer: Muon for 2D matrix params, AdamW for others.
+
+ See MuonAdamW for the algorithmic details of each optimizer. This class adds
+ distributed communication to enable multi-GPU training without PyTorch DDP.
+
+ Design Goals:
+ - Overlap communication with computation (async ops)
+ - Minimize memory by sharding optimizer states across ranks (ZeRO-2 style)
+ - Batch small tensors into single comm ops where possible
+
+ Communication Pattern (3-phase async):
+ We use a 3-phase structure to maximize overlap between communication and compute:
+
+ Phase 1: Launch all async reduce ops
+ - Kick off all reduce_scatter/all_reduce operations
+ - Don't wait - let them run in background while we continue
+
+ Phase 2: Wait for reduces, compute updates, launch gathers
+ - For each group: wait for its reduce, compute the update, launch gather
+ - By processing groups in order, earlier gathers run while later computes happen
+
+ Phase 3: Wait for gathers, copy back
+ - Wait for all gathers to complete
+ - Copy updated params back to original tensors (Muon only)
+
+ AdamW Communication (ZeRO-2 style):
+ - Small params (<1024 elements): all_reduce gradients, update full param on each rank.
+ Optimizer state is replicated but these params are tiny (scalars, biases).
+ - Large params: reduce_scatter gradients so each rank gets 1/N of the grad, update
+ only that slice, then all_gather the updated slices. Optimizer state (exp_avg,
+ exp_avg_sq) is sharded - each rank only stores state for its slice.
+ Requires param.shape[0] divisible by world_size.
+
+ Muon Communication (stacked + chunked):
+ - All params in a Muon group must have the same shape (caller's responsibility).
+ - Stack all K params into a single (K, *shape) tensor for efficient comm.
+ - Divide K params across N ranks: each rank "owns" ceil(K/N) params.
+ - reduce_scatter the stacked grads so each rank gets its chunk.
+ - Each rank computes Muon update only for params it owns.
+ - all_gather the updated params back to all ranks.
+ - Optimizer state (momentum_buffer, second_momentum_buffer) is sharded by chunk.
+ - Padding: if K doesn't divide evenly, we zero-pad to (ceil(K/N) * N) for comm,
+ then ignore the padding when copying back.
+
+ Buffer Reuse:
+ - For Muon, we allocate stacked_grads for reduce_scatter input, then reuse the
+ same buffer as the output for all_gather (stacked_params). This saves memory
+ since we don't need both buffers simultaneously.
+
+ Arguments:
+ param_groups: List of dicts, each containing:
+ - 'params': List of parameters
+ - 'kind': 'adamw' or 'muon'
+ - For AdamW groups: 'lr', 'betas', 'eps', 'weight_decay'
+ - For Muon groups: 'lr', 'momentum', 'ns_steps', 'beta2', 'weight_decay'
+ """
def __init__(self, param_groups: list[dict]):
super().__init__(param_groups, defaults={})
# 0-D CPU tensors to avoid torch.compile recompilation when values change
@@ -259,6 +367,7 @@ self._muon_beta2_t = torch.tensor(0.0, dtype=torch.float32, device="cpu")
def _reduce_adamw(self, group: dict, world_size: int) -> dict:
+ """Launch async reduce ops for AdamW group. Returns info dict with per-param infos."""
param_infos = {}
for p in group['params']:
grad = p.grad
@@ -276,6 +385,7 @@ return dict(param_infos=param_infos)
def _reduce_muon(self, group: dict, world_size: int) -> dict:
+ """Launch async reduce op for Muon group. Returns info dict."""
params = group['params']
chunk_size = (len(params) + world_size - 1) // world_size
padded_num_params = chunk_size * world_size
@@ -296,6 +406,7 @@ return dict(future=future, grad_chunk=grad_chunk, stacked_grads=stacked_grads, chunk_size=chunk_size)
def _compute_adamw(self, group: dict, info: dict, gather_list: list, rank: int, world_size: int) -> None:
+ """Wait for reduce, compute AdamW updates, launch gathers for large params."""
param_infos = info['param_infos']
for p in group['params']:
pinfo = param_infos[p]
@@ -336,6 +447,7 @@ gather_list.append(dict(future=future, params=None))
def _compute_muon(self, group: dict, info: dict, gather_list: list, rank: int) -> None:
+ """Wait for reduce, compute Muon updates, launch gather."""
info['future'].wait()
params = group['params']
chunk_size = info['chunk_size']
@@ -385,6 +497,7 @@ gather_list.append(dict(future=future, stacked_params=stacked_params, params=params))
def _finish_gathers(self, gather_list: list) -> None:
+ """Wait for all gathers and copy Muon params back."""
for info in gather_list:
info["future"].wait()
if info["params"] is not None:
@@ -417,4 +530,4 @@ raise ValueError(f"Unknown optimizer kind: {group['kind']}")
# Phase 3: wait for gathers, copy back
- self._finish_gathers(gather_list)+ self._finish_gathers(gather_list)
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/optim.py |
Add docstrings to incomplete code |
import re
from datasets import load_dataset
from nanochat.execution import execute_code
from tasks.common import Task
def extract_imports(prompt):
imports = []
for line in prompt.split('\n'):
stripped = line.strip()
if stripped.startswith('import ') or stripped.startswith('from '):
imports.append(stripped)
elif stripped and not stripped.startswith('#'):
# Stop at first non-import, non-comment line
break
return '\n'.join(imports)
def extract_program(completion):
# Try to find markdown code blocks (```python or just ```)
# Match ```python\n...\n``` or ```\n...\n```
pattern = r'```(?:python)?\s*\n(.*?)\n```'
matches = re.findall(pattern, completion, re.DOTALL)
if matches:
# Return the first code block found
return matches[0].strip()
# No code blocks found, return the whole completion
return completion.strip()
class HumanEval(Task):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.ds = load_dataset("openai/openai_humaneval", split="test").shuffle(seed=42)
@property
def eval_type(self):
return 'generative'
def num_examples(self):
return len(self.ds)
def get_example(self, index):
row = self.ds[index]
prompt = row['prompt'] # prompts in HumanEval are the beginning of the program
solution = row['canonical_solution'] # the correct continuation of the program
entry_point = row['entry_point'] # the function to check
test = row['test'] # the test cases
complete_solution = f"{prompt}\n{solution}"
messages = [
{"role": "user", "content": prompt},
{"role": "assistant", "content": complete_solution},
]
conversation = {
"messages": messages,
"entry_point": entry_point, # needed during evaluation
"test": test, # needed during evaluation
}
return conversation
def evaluate(self, conversation, completion):
# the prompt will contain the imports and the function signature
imports = extract_imports(conversation['messages'][0]['content'])
# the completion will usually contain the whole function
# but not always with the needed imports, so we manually append them
completion_code = extract_program(completion)
program = (
imports
+ "\n\n"
+ completion_code
+ "\n\n"
+ conversation['test']
+ "\n"
+ f"check({conversation['entry_point']})"
)
result = execute_code(program)
success = result.success
return success | --- +++ @@ -1,3 +1,8 @@+"""
+Evaluate the Chat model on HumanEval dataset.
+Btw this dataset is a misnomer and has nothing to do with humans.
+It is a coding benchmark.
+"""
import re
from datasets import load_dataset
@@ -5,6 +10,7 @@ from tasks.common import Task
def extract_imports(prompt):
+ """Extract import statements from the beginning of a code block."""
imports = []
for line in prompt.split('\n'):
stripped = line.strip()
@@ -16,6 +22,16 @@ return '\n'.join(imports)
def extract_program(completion):
+ """
+ Extract Python code from LLM completion.
+
+ Handles various output formats:
+ - Code wrapped in ```python ... ``` or ``` ... ``` blocks
+ - Plain code without markdown blocks
+ - Extra text before/after code blocks
+
+ Returns the first code block if found, otherwise returns the whole completion.
+ """
# Try to find markdown code blocks (```python or just ```)
# Match ```python\n...\n``` or ```\n...\n```
pattern = r'```(?:python)?\s*\n(.*?)\n```'
@@ -42,6 +58,7 @@ return len(self.ds)
def get_example(self, index):
+ """ Get a single problem from the dataset. """
row = self.ds[index]
prompt = row['prompt'] # prompts in HumanEval are the beginning of the program
solution = row['canonical_solution'] # the correct continuation of the program
@@ -60,6 +77,7 @@ return conversation
def evaluate(self, conversation, completion):
+ """ Given (conversation, completion), return boolean success of the completion. """
# the prompt will contain the imports and the function signature
imports = extract_imports(conversation['messages'][0]['content'])
# the completion will usually contain the whole function
@@ -76,4 +94,4 @@ )
result = execute_code(program)
success = result.success
- return success+ return success
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/humaneval.py |
Document all public functions with docstrings |
import re
from datasets import load_dataset
from tasks.common import Task
GSM_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract_answer(completion):
match = GSM_RE.search(completion)
if match:
match_str = match.group(1).strip()
match_str = match_str.replace(",", "")
return match_str
return None
class GSM8K(Task):
def __init__(self, subset, split, **kwargs):
super().__init__(**kwargs)
assert subset in ["main", "socratic"], "GSM8K subset must be main|socratic"
assert split in ["train", "test"], "GSM8K split must be train|test"
self.ds = load_dataset("openai/gsm8k", subset, split=split).shuffle(seed=42)
@property
def eval_type(self):
return 'generative'
def num_examples(self):
return len(self.ds)
def get_example(self, index):
row = self.ds[index]
question = row['question'] # string of the question prompt
answer = row['answer'] # string of the full solution and the answer after #### marker
# Create and return the Conversation object
# This is tricky because GSM8K uses tool calls, which we need to parse here.
assistant_message_parts = []
parts = re.split(r'(<<[^>]+>>)', answer)
for part in parts:
if part.startswith('<<') and part.endswith('>>'):
# This is a calculator tool call
inner = part[2:-2] # Remove << >>
# Split on = to get expression and result
if '=' in inner:
expr, result = inner.rsplit('=', 1)
else:
expr, result = inner, ""
# Add the tool call as a part
assistant_message_parts.append({"type": "python", "text": expr})
# Add the result as a part
assistant_message_parts.append({"type": "python_output", "text": result})
else:
# Regular text in between tool calls
assistant_message_parts.append({"type": "text", "text": part})
# Now put it all together
messages = [
{"role": "user", "content": question}, # note: simple string
{"role": "assistant", "content": assistant_message_parts}, # note: list of parts (as dicts)
]
conversation = {
"messages": messages,
}
return conversation
def evaluate(self, conversation, assistant_response):
assert isinstance(assistant_response, str), "Assuming simple string response for now"
# First extract the ground truth answer
assistant_message = conversation['messages'][-1]
assert assistant_message['role'] == "assistant", "Last message must be from the Assistant"
assert isinstance(assistant_message['content'], list), "This is expected to be a list of parts"
last_text_part = assistant_message['content'][-1]['text'] # this contains the final answer in GSM8K
# Extract both the ground truth answer and the predicted answer
ref_num = extract_answer(last_text_part)
pred_num = extract_answer(assistant_response)
# Compare and return the success as int
is_correct = int(pred_num == ref_num)
return is_correct
def reward(self, conversation, assistant_response):
is_correct = self.evaluate(conversation, assistant_response)
is_correct_float = float(is_correct)
return is_correct_float | --- +++ @@ -1,3 +1,18 @@+"""
+GSM8K evaluation.
+https://huggingface.co/datasets/openai/gsm8k
+
+Example problem instance:
+
+Question:
+Weng earns $12 an hour for babysitting. Yesterday, she just did 50 minutes of babysitting. How much did she earn?
+Answer:
+Weng earns 12/60 = $<<12/60=0.2>>0.2 per minute.
+Working 50 minutes, she earned 0.2 x 50 = $<<0.2*50=10>>10.
+#### 10
+
+Notice that GSM8K uses tool calls inside << >> tags.
+"""
import re
from datasets import load_dataset
@@ -6,6 +21,11 @@
GSM_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract_answer(completion):
+ """
+ Extract the numerical answer after #### marker.
+ Follows official code for normalization:
+ https://github.com/openai/grade-school-math/blob/3101c7d5072418e28b9008a6636bde82a006892c/grade_school_math/dataset.py#L28
+ """
match = GSM_RE.search(completion)
if match:
match_str = match.group(1).strip()
@@ -30,6 +50,7 @@ return len(self.ds)
def get_example(self, index):
+ """ Get a single problem from the dataset. """
row = self.ds[index]
question = row['question'] # string of the question prompt
answer = row['answer'] # string of the full solution and the answer after #### marker
@@ -64,6 +85,15 @@ return conversation
def evaluate(self, conversation, assistant_response):
+ """
+ Given (conversation, completion), return evaluation outcome (0 = wrong, 1 = correct)
+ Note that:
+ - the conversation has both user AND assistant message (containing the ground truth answer)
+ - the assistant_response is usually the alternative assistant message achieved via sampling
+
+ TODO: Technically, assistant_response should be a Message (either a string or a list of parts)
+ We can handle this later possibly. For now just assume string.
+ """
assert isinstance(assistant_response, str), "Assuming simple string response for now"
# First extract the ground truth answer
assistant_message = conversation['messages'][-1]
@@ -78,6 +108,10 @@ return is_correct
def reward(self, conversation, assistant_response):
+ """
+ Used during RL. To keep things simple, just re-use the evaluation above.
+ Later this could be made more complex (e.g. format matching etc.)
+ """
is_correct = self.evaluate(conversation, assistant_response)
is_correct_float = float(is_correct)
- return is_correct_float+ return is_correct_float
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/gsm8k.py |
Document all endpoints with docstrings |
import hashlib
import json
import os
import socket
from app.database import SessionLocal
from app.models import Config as ConfigModel
from mem0 import Memory
_memory_client = None
_config_hash = None
def _get_config_hash(config_dict):
config_str = json.dumps(config_dict, sort_keys=True)
return hashlib.md5(config_str.encode()).hexdigest()
def _get_docker_host_url():
# Check for custom environment variable first
custom_host = os.environ.get('OLLAMA_HOST')
if custom_host:
print(f"Using custom Ollama host from OLLAMA_HOST: {custom_host}")
return custom_host.replace('http://', '').replace('https://', '').split(':')[0]
# Check if we're running inside Docker
if not os.path.exists('/.dockerenv'):
# Not in Docker, return localhost as-is
return "localhost"
print("Detected Docker environment, adjusting host URL for Ollama...")
# Try different host resolution strategies
host_candidates = []
# 1. host.docker.internal (works on Docker Desktop for Mac/Windows)
try:
socket.gethostbyname('host.docker.internal')
host_candidates.append('host.docker.internal')
print("Found host.docker.internal")
except socket.gaierror:
pass
# 2. Docker bridge gateway (typically 172.17.0.1 on Linux)
try:
with open('/proc/net/route', 'r') as f:
for line in f:
fields = line.strip().split()
if fields[1] == '00000000': # Default route
gateway_hex = fields[2]
gateway_ip = socket.inet_ntoa(bytes.fromhex(gateway_hex)[::-1])
host_candidates.append(gateway_ip)
print(f"Found Docker gateway: {gateway_ip}")
break
except (FileNotFoundError, IndexError, ValueError):
pass
# 3. Fallback to common Docker bridge IP
if not host_candidates:
host_candidates.append('172.17.0.1')
print("Using fallback Docker bridge IP: 172.17.0.1")
# Return the first available candidate
return host_candidates[0]
def _fix_ollama_urls(config_section):
if not config_section or "config" not in config_section:
return config_section
ollama_config = config_section["config"]
# Set default ollama_base_url if not provided
if "ollama_base_url" not in ollama_config:
ollama_config["ollama_base_url"] = "http://host.docker.internal:11434"
else:
# Check for ollama_base_url and fix if it's localhost
url = ollama_config["ollama_base_url"]
if "localhost" in url or "127.0.0.1" in url:
docker_host = _get_docker_host_url()
if docker_host != "localhost":
new_url = url.replace("localhost", docker_host).replace("127.0.0.1", docker_host)
ollama_config["ollama_base_url"] = new_url
print(f"Adjusted Ollama URL from {url} to {new_url}")
return config_section
def reset_memory_client():
global _memory_client, _config_hash
_memory_client = None
_config_hash = None
def get_default_memory_config():
# Detect vector store based on environment variables
vector_store_config = {
"collection_name": "openmemory",
"host": "mem0_store",
}
# Check for different vector store configurations based on environment variables
if os.environ.get('CHROMA_HOST') and os.environ.get('CHROMA_PORT'):
vector_store_provider = "chroma"
vector_store_config.update({
"host": os.environ.get('CHROMA_HOST'),
"port": int(os.environ.get('CHROMA_PORT'))
})
elif os.environ.get('QDRANT_HOST') and os.environ.get('QDRANT_PORT'):
vector_store_provider = "qdrant"
vector_store_config.update({
"host": os.environ.get('QDRANT_HOST'),
"port": int(os.environ.get('QDRANT_PORT'))
})
elif os.environ.get('WEAVIATE_CLUSTER_URL') or (os.environ.get('WEAVIATE_HOST') and os.environ.get('WEAVIATE_PORT')):
vector_store_provider = "weaviate"
# Prefer an explicit cluster URL if provided; otherwise build from host/port
cluster_url = os.environ.get('WEAVIATE_CLUSTER_URL')
if not cluster_url:
weaviate_host = os.environ.get('WEAVIATE_HOST')
weaviate_port = int(os.environ.get('WEAVIATE_PORT'))
cluster_url = f"http://{weaviate_host}:{weaviate_port}"
vector_store_config = {
"collection_name": "openmemory",
"cluster_url": cluster_url
}
elif os.environ.get('REDIS_URL'):
vector_store_provider = "redis"
vector_store_config = {
"collection_name": "openmemory",
"redis_url": os.environ.get('REDIS_URL')
}
elif os.environ.get('PG_HOST') and os.environ.get('PG_PORT'):
vector_store_provider = "pgvector"
vector_store_config.update({
"host": os.environ.get('PG_HOST'),
"port": int(os.environ.get('PG_PORT')),
"dbname": os.environ.get('PG_DB', 'mem0'),
"user": os.environ.get('PG_USER', 'mem0'),
"password": os.environ.get('PG_PASSWORD', 'mem0')
})
elif os.environ.get('MILVUS_HOST') and os.environ.get('MILVUS_PORT'):
vector_store_provider = "milvus"
# Construct the full URL as expected by MilvusDBConfig
milvus_host = os.environ.get('MILVUS_HOST')
milvus_port = int(os.environ.get('MILVUS_PORT'))
milvus_url = f"http://{milvus_host}:{milvus_port}"
vector_store_config = {
"collection_name": "openmemory",
"url": milvus_url,
"token": os.environ.get('MILVUS_TOKEN', ''), # Always include, empty string for local setup
"db_name": os.environ.get('MILVUS_DB_NAME', ''),
"embedding_model_dims": 1536,
"metric_type": "COSINE" # Using COSINE for better semantic similarity
}
elif os.environ.get('ELASTICSEARCH_HOST') and os.environ.get('ELASTICSEARCH_PORT'):
vector_store_provider = "elasticsearch"
# Construct the full URL with scheme since Elasticsearch client expects it
elasticsearch_host = os.environ.get('ELASTICSEARCH_HOST')
elasticsearch_port = int(os.environ.get('ELASTICSEARCH_PORT'))
# Use http:// scheme since we're not using SSL
full_host = f"http://{elasticsearch_host}"
vector_store_config.update({
"host": full_host,
"port": elasticsearch_port,
"user": os.environ.get('ELASTICSEARCH_USER', 'elastic'),
"password": os.environ.get('ELASTICSEARCH_PASSWORD', 'changeme'),
"verify_certs": False,
"use_ssl": False,
"embedding_model_dims": 1536
})
elif os.environ.get('OPENSEARCH_HOST') and os.environ.get('OPENSEARCH_PORT'):
vector_store_provider = "opensearch"
vector_store_config.update({
"host": os.environ.get('OPENSEARCH_HOST'),
"port": int(os.environ.get('OPENSEARCH_PORT'))
})
elif os.environ.get('FAISS_PATH'):
vector_store_provider = "faiss"
vector_store_config = {
"collection_name": "openmemory",
"path": os.environ.get('FAISS_PATH'),
"embedding_model_dims": 1536,
"distance_strategy": "cosine"
}
else:
# Default fallback to Qdrant
vector_store_provider = "qdrant"
vector_store_config.update({
"port": 6333,
})
print(f"Auto-detected vector store: {vector_store_provider} with config: {vector_store_config}")
return {
"vector_store": {
"provider": vector_store_provider,
"config": vector_store_config
},
"llm": {
"provider": "openai",
"config": {
"model": "gpt-4o-mini",
"temperature": 0.1,
"max_tokens": 2000,
"api_key": "env:OPENAI_API_KEY"
}
},
"embedder": {
"provider": "openai",
"config": {
"model": "text-embedding-3-small",
"api_key": "env:OPENAI_API_KEY"
}
},
"version": "v1.1"
}
def _parse_environment_variables(config_dict):
if isinstance(config_dict, dict):
parsed_config = {}
for key, value in config_dict.items():
if isinstance(value, str) and value.startswith("env:"):
env_var = value.split(":", 1)[1]
env_value = os.environ.get(env_var)
if env_value:
parsed_config[key] = env_value
print(f"Loaded {env_var} from environment for {key}")
else:
print(f"Warning: Environment variable {env_var} not found, keeping original value")
parsed_config[key] = value
elif isinstance(value, dict):
parsed_config[key] = _parse_environment_variables(value)
else:
parsed_config[key] = value
return parsed_config
return config_dict
def get_memory_client(custom_instructions: str = None):
global _memory_client, _config_hash
try:
# Start with default configuration
config = get_default_memory_config()
# Variable to track custom instructions
db_custom_instructions = None
# Load configuration from database
try:
db = SessionLocal()
db_config = db.query(ConfigModel).filter(ConfigModel.key == "main").first()
if db_config:
json_config = db_config.value
# Extract custom instructions from openmemory settings
if "openmemory" in json_config and "custom_instructions" in json_config["openmemory"]:
db_custom_instructions = json_config["openmemory"]["custom_instructions"]
# Override defaults with configurations from the database
if "mem0" in json_config:
mem0_config = json_config["mem0"]
# Update LLM configuration if available
if "llm" in mem0_config and mem0_config["llm"] is not None:
config["llm"] = mem0_config["llm"]
# Fix Ollama URLs for Docker if needed
if config["llm"].get("provider") == "ollama":
config["llm"] = _fix_ollama_urls(config["llm"])
# Update Embedder configuration if available
if "embedder" in mem0_config and mem0_config["embedder"] is not None:
config["embedder"] = mem0_config["embedder"]
# Fix Ollama URLs for Docker if needed
if config["embedder"].get("provider") == "ollama":
config["embedder"] = _fix_ollama_urls(config["embedder"])
if "vector_store" in mem0_config and mem0_config["vector_store"] is not None:
config["vector_store"] = mem0_config["vector_store"]
else:
print("No configuration found in database, using defaults")
db.close()
except Exception as e:
print(f"Warning: Error loading configuration from database: {e}")
print("Using default configuration")
# Continue with default configuration if database config can't be loaded
# Use custom_instructions parameter first, then fall back to database value
instructions_to_use = custom_instructions or db_custom_instructions
if instructions_to_use:
config["custom_fact_extraction_prompt"] = instructions_to_use
# ALWAYS parse environment variables in the final config
# This ensures that even default config values like "env:OPENAI_API_KEY" get parsed
print("Parsing environment variables in final config...")
config = _parse_environment_variables(config)
# Check if config has changed by comparing hashes
current_config_hash = _get_config_hash(config)
# Only reinitialize if config changed or client doesn't exist
if _memory_client is None or _config_hash != current_config_hash:
print(f"Initializing memory client with config hash: {current_config_hash}")
try:
_memory_client = Memory.from_config(config_dict=config)
_config_hash = current_config_hash
print("Memory client initialized successfully")
except Exception as init_error:
print(f"Warning: Failed to initialize memory client: {init_error}")
print("Server will continue running with limited memory functionality")
_memory_client = None
_config_hash = None
return None
return _memory_client
except Exception as e:
print(f"Warning: Exception occurred while initializing memory client: {e}")
print("Server will continue running with limited memory functionality")
return None
def get_default_user_id():
return "default_user" | --- +++ @@ -1,3 +1,31 @@+"""
+Memory client utilities for OpenMemory.
+
+This module provides functionality to initialize and manage the Mem0 memory client
+with automatic configuration management and Docker environment support.
+
+Docker Ollama Configuration:
+When running inside a Docker container and using Ollama as the LLM or embedder provider,
+the system automatically detects the Docker environment and adjusts localhost URLs
+to properly reach the host machine where Ollama is running.
+
+Supported Docker host resolution (in order of preference):
+1. OLLAMA_HOST environment variable (if set)
+2. host.docker.internal (Docker Desktop for Mac/Windows)
+3. Docker bridge gateway IP (typically 172.17.0.1 on Linux)
+4. Fallback to 172.17.0.1
+
+Example configuration that will be automatically adjusted:
+{
+ "llm": {
+ "provider": "ollama",
+ "config": {
+ "model": "llama3.1:latest",
+ "ollama_base_url": "http://localhost:11434" # Auto-adjusted in Docker
+ }
+ }
+}
+"""
import hashlib
import json
@@ -14,11 +42,16 @@
def _get_config_hash(config_dict):
+ """Generate a hash of the config to detect changes."""
config_str = json.dumps(config_dict, sort_keys=True)
return hashlib.md5(config_str.encode()).hexdigest()
def _get_docker_host_url():
+ """
+ Determine the appropriate host URL to reach host machine from inside Docker container.
+ Returns the best available option for reaching the host from inside a container.
+ """
# Check for custom environment variable first
custom_host = os.environ.get('OLLAMA_HOST')
if custom_host:
@@ -67,6 +100,11 @@
def _fix_ollama_urls(config_section):
+ """
+ Fix Ollama URLs for Docker environment.
+ Replaces localhost URLs with appropriate Docker host URLs.
+ Sets default ollama_base_url if not provided.
+ """
if not config_section or "config" not in config_section:
return config_section
@@ -89,12 +127,14 @@
def reset_memory_client():
+ """Reset the global memory client to force reinitialization with new config."""
global _memory_client, _config_hash
_memory_client = None
_config_hash = None
def get_default_memory_config():
+ """Get default memory client configuration with sensible defaults."""
# Detect vector store based on environment variables
vector_store_config = {
"collection_name": "openmemory",
@@ -222,6 +262,10 @@
def _parse_environment_variables(config_dict):
+ """
+ Parse environment variables in config values.
+ Converts 'env:VARIABLE_NAME' to actual environment variable values.
+ """
if isinstance(config_dict, dict):
parsed_config = {}
for key, value in config_dict.items():
@@ -243,6 +287,18 @@
def get_memory_client(custom_instructions: str = None):
+ """
+ Get or initialize the Mem0 client.
+
+ Args:
+ custom_instructions: Optional instructions for the memory project.
+
+ Returns:
+ Initialized Mem0 client instance or None if initialization fails.
+
+ Raises:
+ Exception: If required API keys are not set or critical configuration is missing.
+ """
global _memory_client, _config_hash
try:
@@ -332,4 +388,4 @@
def get_default_user_id():
- return "default_user"+ return "default_user"
| https://raw.githubusercontent.com/mem0ai/mem0/HEAD/openmemory/api/app/utils/memory.py |
Add docstrings to existing functions | import torch
import torch.nn.functional as F
# =============================================================================
# Detection: Try to load FA3 on Hopper+ GPUs
# =============================================================================
def _load_flash_attention_3():
if not torch.cuda.is_available():
return None
try:
major, _ = torch.cuda.get_device_capability()
# FA3 kernels are compiled for Hopper (sm90) only
# Ada (sm89), Blackwell (sm100) need SDPA fallback until FA3 is recompiled
if major != 9:
return None
import os
os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
from kernels import get_kernel
return get_kernel('varunneal/flash-attention-3').flash_attn_interface
except Exception:
return None
_fa3 = _load_flash_attention_3()
HAS_FA3 = _fa3 is not None
# Override for testing: set to 'fa3', 'sdpa', or None (auto)
_override_impl = None
def _resolve_use_fa3():
if _override_impl == 'fa3':
assert HAS_FA3, "Cannot override to FA3: not available on this hardware"
return True
if _override_impl == 'sdpa':
return False
if HAS_FA3:
# FA3 Hopper kernels only support bf16 and fp8; fp16/fp32 must use SDPA fallback
from nanochat.common import COMPUTE_DTYPE
if COMPUTE_DTYPE == torch.bfloat16:
return True
return False
return False
USE_FA3 = _resolve_use_fa3()
# =============================================================================
# SDPA helpers
# =============================================================================
def _sdpa_attention(q, k, v, window_size, enable_gqa):
Tq = q.size(2)
Tk = k.size(2)
window = window_size[0]
# Full context, same length
if (window < 0 or window >= Tq) and Tq == Tk:
return F.scaled_dot_product_attention(q, k, v, is_causal=True, enable_gqa=enable_gqa)
# Single token generation
if Tq == 1:
if window >= 0 and window < Tk:
# window is "left" tokens we need to include (window + 1) keys total
start = max(0, Tk - (window + 1))
k = k[:, :, start:, :]
v = v[:, :, start:, :]
return F.scaled_dot_product_attention(q, k, v, is_causal=False, enable_gqa=enable_gqa)
# Need explicit mask for sliding window/chunk inference
device = q.device
# For chunk inference (Tq != Tk), is_causal is not aligned to cache position => build an explicit bool mask
row_idx = (Tk - Tq) + torch.arange(Tq, device=device).unsqueeze(1)
col_idx = torch.arange(Tk, device=device).unsqueeze(0)
mask = col_idx <= row_idx
# sliding window (left)
if window >= 0 and window < Tk:
mask = mask & ((row_idx - col_idx) <= window)
return F.scaled_dot_product_attention(q, k, v, attn_mask=mask, enable_gqa=enable_gqa)
# =============================================================================
# Public API: Same interface as FA3
# =============================================================================
def flash_attn_func(q, k, v, causal=False, window_size=(-1, -1)):
if USE_FA3:
return _fa3.flash_attn_func(q, k, v, causal=causal, window_size=window_size)
# SDPA fallback: transpose (B, T, H, D) -> (B, H, T, D)
q = q.transpose(1, 2)
k = k.transpose(1, 2)
v = v.transpose(1, 2)
enable_gqa = q.size(1) != k.size(1)
y = _sdpa_attention(q, k, v, window_size, enable_gqa)
return y.transpose(1, 2) # back to (B, T, H, D)
def flash_attn_with_kvcache(q, k_cache, v_cache, k=None, v=None, cache_seqlens=None,
causal=False, window_size=(-1, -1)):
if USE_FA3:
return _fa3.flash_attn_with_kvcache(
q, k_cache, v_cache, k=k, v=v, cache_seqlens=cache_seqlens,
causal=causal, window_size=window_size
)
# SDPA fallback: manually manage KV cache
B, T_new, H, D = q.shape
pos = cache_seqlens[0].item() # assume uniform position across batch
# Insert new k, v into cache (in-place, matching FA3 behavior)
if k is not None and v is not None:
k_cache[:, pos:pos+T_new, :, :] = k
v_cache[:, pos:pos+T_new, :, :] = v
# Get full cache up to current position + new tokens
end_pos = pos + T_new
k_full = k_cache[:, :end_pos, :, :]
v_full = v_cache[:, :end_pos, :, :]
# Transpose to SDPA layout: (B, T, H, D) -> (B, H, T, D)
q_sdpa = q.transpose(1, 2)
k_sdpa = k_full.transpose(1, 2)
v_sdpa = v_full.transpose(1, 2)
enable_gqa = q_sdpa.size(1) != k_sdpa.size(1)
y_sdpa = _sdpa_attention(q_sdpa, k_sdpa, v_sdpa, window_size, enable_gqa)
return y_sdpa.transpose(1, 2) # back to (B, T, H, D)
# =============================================================================
# Export: flash_attn module interface (drop-in replacement for FA3)
# =============================================================================
from types import SimpleNamespace
flash_attn = SimpleNamespace(
flash_attn_func=flash_attn_func,
flash_attn_with_kvcache=flash_attn_with_kvcache,
) | --- +++ @@ -1,3 +1,18 @@+"""
+Unified Flash Attention interface with automatic FA3/SDPA switching.
+
+Exports `flash_attn` module that matches the FA3 API exactly, but falls back
+to PyTorch SDPA on non-Hopper GPUs (including Blackwell), MPS, and CPU.
+
+Usage (drop-in replacement for FA3):
+ from nanochat.flash_attention import flash_attn
+
+ # Training (no KV cache)
+ y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
+
+ # Inference (with KV cache)
+ y = flash_attn.flash_attn_with_kvcache(q, k_cache, v_cache, k=k, v=v, ...)
+"""
import torch
import torch.nn.functional as F
@@ -6,6 +21,7 @@ # Detection: Try to load FA3 on Hopper+ GPUs
# =============================================================================
def _load_flash_attention_3():
+ """Try to load Flash Attention 3 (requires Hopper GPU, sm90)."""
if not torch.cuda.is_available():
return None
try:
@@ -30,6 +46,7 @@
def _resolve_use_fa3():
+ """Decide once whether to use FA3, based on availability, override, and dtype."""
if _override_impl == 'fa3':
assert HAS_FA3, "Cannot override to FA3: not available on this hardware"
return True
@@ -50,6 +67,10 @@ # SDPA helpers
# =============================================================================
def _sdpa_attention(q, k, v, window_size, enable_gqa):
+ """
+ SDPA attention with sliding window support.
+ q, k, v are (B, H, T, D) format.
+ """
Tq = q.size(2)
Tk = k.size(2)
window = window_size[0]
@@ -84,6 +105,17 @@ # Public API: Same interface as FA3
# =============================================================================
def flash_attn_func(q, k, v, causal=False, window_size=(-1, -1)):
+ """
+ Flash Attention for training (no KV cache).
+
+ Args:
+ q, k, v: Tensors of shape (B, T, H, D)
+ causal: Whether to use causal masking
+ window_size: (left, right) sliding window. -1 means unlimited.
+
+ Returns:
+ Output tensor of shape (B, T, H, D)
+ """
if USE_FA3:
return _fa3.flash_attn_func(q, k, v, causal=causal, window_size=window_size)
@@ -98,6 +130,22 @@
def flash_attn_with_kvcache(q, k_cache, v_cache, k=None, v=None, cache_seqlens=None,
causal=False, window_size=(-1, -1)):
+ """
+ Flash Attention with KV cache for inference.
+
+ FA3 updates k_cache/v_cache in-place. Our SDPA fallback does the same.
+
+ Args:
+ q: Queries, shape (B, T_new, H, D)
+ k_cache, v_cache: Pre-allocated cache tensors, shape (B, T_max, H_kv, D)
+ k, v: New keys/values to insert, shape (B, T_new, H_kv, D)
+ cache_seqlens: Current position in cache, shape (B,) int32
+ causal: Whether to use causal masking
+ window_size: (left, right) sliding window. -1 means unlimited.
+
+ Returns:
+ Output tensor of shape (B, T_new, H, D)
+ """
if USE_FA3:
return _fa3.flash_attn_with_kvcache(
q, k_cache, v_cache, k=k, v=v, cache_seqlens=cache_seqlens,
@@ -136,4 +184,4 @@ flash_attn = SimpleNamespace(
flash_attn_func=flash_attn_func,
flash_attn_with_kvcache=flash_attn_with_kvcache,
-)+)
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/flash_attention.py |
Write docstrings for data processing functions | from abc import ABC, abstractmethod
from typing import List, Dict, Any
class BaseReranker(ABC):
@abstractmethod
def rerank(self, query: str, documents: List[Dict[str, Any]], top_k: int = None) -> List[Dict[str, Any]]:
pass | --- +++ @@ -2,7 +2,19 @@ from typing import List, Dict, Any
class BaseReranker(ABC):
+ """Abstract base class for all rerankers."""
@abstractmethod
def rerank(self, query: str, documents: List[Dict[str, Any]], top_k: int = None) -> List[Dict[str, Any]]:
+ """
+ Rerank documents based on relevance to the query.
+
+ Args:
+ query: The search query
+ documents: List of documents to rerank, each with 'memory' field
+ top_k: Number of top documents to return (None = return all)
+
+ Returns:
+ List of reranked documents with added 'rerank_score' field
+ """
pass | https://raw.githubusercontent.com/mem0ai/mem0/HEAD/mem0/reranker/base.py |
Generate docstrings with parameter types |
from functools import partial
from dataclasses import dataclass
import torch
import torch.nn as nn
import torch.nn.functional as F
from nanochat.common import get_dist_info, print0, COMPUTE_DTYPE
from nanochat.optim import MuonAdamW, DistMuonAdamW
# Our custom Flash Attention module that automatically uses FA3 on Hopper+ and SDPA fallback elsewhere
from nanochat.flash_attention import flash_attn
@dataclass
class GPTConfig:
sequence_len: int = 2048
vocab_size: int = 32768
n_layer: int = 12
n_head: int = 6 # number of query heads
n_kv_head: int = 6 # number of key/value heads (GQA)
n_embd: int = 768
# Sliding window attention pattern string, tiled across layers. Final layer always L.
# Characters: L=long (full context), S=short (quarter context)
# Examples: "L"=all full context, "SL"=alternating, "SSL"=two short then one long
window_pattern: str = "SSSL"
def norm(x):
return F.rms_norm(x, (x.size(-1),)) # note that this will run in bf16, seems ok
class Linear(nn.Linear):
def forward(self, x):
return F.linear(x, self.weight.to(dtype=x.dtype))
def has_ve(layer_idx, n_layer):
return layer_idx % 2 == (n_layer - 1) % 2
def apply_rotary_emb(x, cos, sin):
assert x.ndim == 4 # multihead attention
d = x.shape[3] // 2
x1, x2 = x[..., :d], x[..., d:] # split up last dim into two halves
y1 = x1 * cos + x2 * sin # rotate pairs of dims
y2 = x1 * (-sin) + x2 * cos
return torch.cat([y1, y2], 3)
class CausalSelfAttention(nn.Module):
def __init__(self, config, layer_idx):
super().__init__()
self.layer_idx = layer_idx
self.n_head = config.n_head
self.n_kv_head = config.n_kv_head
self.n_embd = config.n_embd
self.head_dim = self.n_embd // self.n_head
assert self.n_embd % self.n_head == 0
assert self.n_kv_head <= self.n_head and self.n_head % self.n_kv_head == 0
self.c_q = Linear(self.n_embd, self.n_head * self.head_dim, bias=False)
self.c_k = Linear(self.n_embd, self.n_kv_head * self.head_dim, bias=False)
self.c_v = Linear(self.n_embd, self.n_kv_head * self.head_dim, bias=False)
self.c_proj = Linear(self.n_embd, self.n_embd, bias=False)
self.ve_gate_channels = 12
self.ve_gate = Linear(self.ve_gate_channels, self.n_kv_head, bias=False) if has_ve(layer_idx, config.n_layer) else None
def forward(self, x, ve, cos_sin, window_size, kv_cache):
B, T, C = x.size()
# Project the input to get queries, keys, and values
# Shape: (B, T, H, D) - FA3's native layout, no transpose needed!
q = self.c_q(x).view(B, T, self.n_head, self.head_dim)
k = self.c_k(x).view(B, T, self.n_kv_head, self.head_dim)
v = self.c_v(x).view(B, T, self.n_kv_head, self.head_dim)
# Value residual (ResFormer): mix in value embedding with input-dependent gate per head
if ve is not None:
ve = ve.view(B, T, self.n_kv_head, self.head_dim)
gate = 3 * torch.sigmoid(self.ve_gate(x[..., :self.ve_gate_channels])) # (B, T, n_kv_head), range (0, 3)
v = v + gate.unsqueeze(-1) * ve
# Apply Rotary Embeddings to queries and keys to get relative positional encoding
cos, sin = cos_sin
q, k = apply_rotary_emb(q, cos, sin), apply_rotary_emb(k, cos, sin)
q, k = norm(q), norm(k) # QK norm
q = q * 1.2 # sharper attention (split scale between Q and K), TODO think through better
k = k * 1.2
# Flash Attention (FA3 on Hopper+, PyTorch SDPA fallback elsewhere)
# window_size is (left, right) tuple: (N, 0) for causal, (-1, 0) for full context
if kv_cache is None:
# Training: causal attention with optional sliding window
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
else:
# Inference: use flash_attn_with_kvcache which handles cache management
k_cache, v_cache = kv_cache.get_layer_cache(self.layer_idx)
y = flash_attn.flash_attn_with_kvcache(
q, k_cache, v_cache,
k=k, v=v,
cache_seqlens=kv_cache.cache_seqlens,
causal=True,
window_size=window_size,
)
# Advance position after last layer processes
if self.layer_idx == kv_cache.n_layers - 1:
kv_cache.advance(T)
# Re-assemble the heads and project back to residual stream
y = y.contiguous().view(B, T, -1)
y = self.c_proj(y)
return y
class MLP(nn.Module):
def __init__(self, config):
super().__init__()
self.c_fc = Linear(config.n_embd, 4 * config.n_embd, bias=False)
self.c_proj = Linear(4 * config.n_embd, config.n_embd, bias=False)
def forward(self, x):
x = self.c_fc(x)
x = F.relu(x).square()
x = self.c_proj(x)
return x
class Block(nn.Module):
def __init__(self, config, layer_idx):
super().__init__()
self.attn = CausalSelfAttention(config, layer_idx)
self.mlp = MLP(config)
def forward(self, x, ve, cos_sin, window_size, kv_cache):
x = x + self.attn(norm(x), ve, cos_sin, window_size, kv_cache)
x = x + self.mlp(norm(x))
return x
class GPT(nn.Module):
def __init__(self, config, pad_vocab_size_to=64):
super().__init__()
self.config = config
# Compute per-layer window sizes for sliding window attention
# window_size is (left, right) tuple: (-1, 0) for full context, (N, 0) for sliding window
self.window_sizes = self._compute_window_sizes(config)
# Pad vocab for efficiency (DDP, tensor cores). This is just an optimization - outputs are cropped in forward().
# https://huggingface.co/docs/transformers/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings
padded_vocab_size = ((config.vocab_size + pad_vocab_size_to - 1) // pad_vocab_size_to) * pad_vocab_size_to
if padded_vocab_size != config.vocab_size:
print0(f"Padding vocab_size from {config.vocab_size} to {padded_vocab_size} for efficiency")
self.transformer = nn.ModuleDict({
"wte": nn.Embedding(padded_vocab_size, config.n_embd),
"h": nn.ModuleList([Block(config, layer_idx) for layer_idx in range(config.n_layer)]),
})
self.lm_head = Linear(config.n_embd, padded_vocab_size, bias=False)
# Per-layer learnable scalars (inspired by modded-nanogpt)
# resid_lambdas: scales the residual stream at each layer (init 1.0 = neutral)
# x0_lambdas: blends initial embedding back in at each layer (init 0.0 = disabled)
# Separate parameters so they can have different optimizer treatment
self.resid_lambdas = nn.Parameter(torch.ones(config.n_layer)) # fake init, real init in init_weights()
self.x0_lambdas = nn.Parameter(torch.zeros(config.n_layer)) # fake init, real init in init_weights()
# Smear: mix previous token's embedding into current token (cheap bigram-like info)
self.smear_gate = Linear(24, 1, bias=False)
self.smear_lambda = nn.Parameter(torch.zeros(1))
# Backout: subtract cached mid-layer residual before final norm to remove low-level features
self.backout_lambda = nn.Parameter(0.2 * torch.ones(1))
# Value embeddings (ResFormer-style): alternating layers, last layer always included
head_dim = config.n_embd // config.n_head
kv_dim = config.n_kv_head * head_dim
self.value_embeds = nn.ModuleDict({str(i): nn.Embedding(padded_vocab_size, kv_dim) for i in range(config.n_layer) if has_ve(i, config.n_layer)})
# To support meta device initialization, we init the rotary embeddings here, but it's just "fake" meta tensors only.
# As for rotary_seq_len, these rotary embeddings are pretty small/cheap in memory,
# so let's just over-compute them by 10X, but assert fail if we ever reach that amount.
# In the future we can dynamically grow the cache, for now it's fine.
self.rotary_seq_len = config.sequence_len * 10 # 10X over-compute should be enough, TODO make nicer?
head_dim = config.n_embd // config.n_head
cos, sin = self._precompute_rotary_embeddings(self.rotary_seq_len, head_dim)
self.register_buffer("cos", cos, persistent=False) # persistent=False means it's not saved to the checkpoint
self.register_buffer("sin", sin, persistent=False)
@torch.no_grad()
def init_weights(self):
# Embedding and unembedding
torch.nn.init.normal_(self.transformer.wte.weight, mean=0.0, std=0.8)
torch.nn.init.normal_(self.lm_head.weight, mean=0.0, std=0.001)
# Transformer blocks: uniform init with bound = sqrt(3) * std (same standard deviation as normal)
n_embd = self.config.n_embd
s = 3**0.5 * n_embd**-0.5 # sqrt(3) multiplier makes sure Uniform achieves the same std as Normal
for block in self.transformer.h:
torch.nn.init.uniform_(block.attn.c_q.weight, -s, s) # weights use Uniform to avoid outliers
torch.nn.init.uniform_(block.attn.c_k.weight, -s, s)
torch.nn.init.uniform_(block.attn.c_v.weight, -s, s)
torch.nn.init.zeros_(block.attn.c_proj.weight) # projections are zero
torch.nn.init.uniform_(block.mlp.c_fc.weight, -s * 0.4, s * 0.4) # 0.4x init scale for c_fc
torch.nn.init.zeros_(block.mlp.c_proj.weight)
# Per-layer scalars
# Per-layer resid init: stronger residual at early layers, weaker at deep layers
n_layer = self.config.n_layer
for i in range(n_layer):
self.resid_lambdas.data[i] = 1.15 - (0.10 * i / max(n_layer - 1, 1))
# Decaying x0 init: earlier layers get more input embedding blending
for i in range(n_layer):
self.x0_lambdas.data[i] = 0.20 - (0.15 * i / max(n_layer - 1, 1))
# Value embeddings (init like c_v: uniform with same std)
for ve in self.value_embeds.values():
torch.nn.init.uniform_(ve.weight, -s, s)
# Gate weights init with small positive values so gates start slightly above neutral
for block in self.transformer.h:
if block.attn.ve_gate is not None:
torch.nn.init.uniform_(block.attn.ve_gate.weight, 0.0, 0.02)
# Rotary embeddings
head_dim = self.config.n_embd // self.config.n_head
cos, sin = self._precompute_rotary_embeddings(self.rotary_seq_len, head_dim)
self.cos, self.sin = cos, sin
# Cast embeddings to COMPUTE_DTYPE: optimizer can tolerate reduced-precision
# embeddings and it saves memory. Exception: fp16 requires fp32 embeddings
# because GradScaler cannot unscale fp16 gradients.
if COMPUTE_DTYPE != torch.float16:
self.transformer.wte.to(dtype=COMPUTE_DTYPE)
for ve in self.value_embeds.values():
ve.to(dtype=COMPUTE_DTYPE)
def _precompute_rotary_embeddings(self, seq_len, head_dim, base=100000, device=None):
# TODO: bump base theta more? e.g. 100K is more common more recently
# autodetect the device from model embeddings
if device is None:
device = self.transformer.wte.weight.device
# stride the channels
channel_range = torch.arange(0, head_dim, 2, dtype=torch.float32, device=device)
inv_freq = 1.0 / (base ** (channel_range / head_dim))
# stride the time steps
t = torch.arange(seq_len, dtype=torch.float32, device=device)
# calculate the rotation frequencies at each (time, channel) pair
freqs = torch.outer(t, inv_freq)
cos, sin = freqs.cos(), freqs.sin()
cos, sin = cos.to(COMPUTE_DTYPE), sin.to(COMPUTE_DTYPE)
cos, sin = cos[None, :, None, :], sin[None, :, None, :] # add batch and head dims for later broadcasting
return cos, sin
def _compute_window_sizes(self, config):
pattern = config.window_pattern.upper()
assert all(c in "SL" for c in pattern), f"Invalid window_pattern: {pattern}. Use only S and L."
# Map characters to window sizes
long_window = config.sequence_len
short_window = -(-long_window // 4 // 128) * 128 # ceil to FA3 tile size (2048 -> 768)
char_to_window = {
"L": (long_window, 0),
"S": (short_window, 0),
}
# Tile pattern across layers
window_sizes = []
for layer_idx in range(config.n_layer):
char = pattern[layer_idx % len(pattern)]
window_sizes.append(char_to_window[char])
# Final layer always gets full context
window_sizes[-1] = (long_window, 0)
return window_sizes
def get_device(self):
return self.transformer.wte.weight.device
def estimate_flops(self):
nparams = sum(p.numel() for p in self.parameters())
# Exclude non-matmul params: embeddings and per-layer scalars
value_embeds_numel = sum(ve.weight.numel() for ve in self.value_embeds.values())
nparams_exclude = (self.transformer.wte.weight.numel() + value_embeds_numel +
self.resid_lambdas.numel() + self.x0_lambdas.numel() +
self.smear_gate.weight.numel() + self.smear_lambda.numel() + self.backout_lambda.numel())
h, q, t = self.config.n_head, self.config.n_embd // self.config.n_head, self.config.sequence_len
# Sum attention FLOPs per layer, accounting for sliding window
attn_flops = 0
for window_size in self.window_sizes:
window = window_size[0] # (left, right) tuple, we use left
effective_seq = t if window < 0 else min(window, t)
attn_flops += 12 * h * q * effective_seq
num_flops_per_token = 6 * (nparams - nparams_exclude) + attn_flops
return num_flops_per_token
def num_scaling_params(self):
# Count each group separately (mirrors the grouping in setup_optimizers)
wte = sum(p.numel() for p in self.transformer.wte.parameters())
value_embeds = sum(p.numel() for p in self.value_embeds.parameters())
lm_head = sum(p.numel() for p in self.lm_head.parameters())
transformer_matrices = sum(p.numel() for p in self.transformer.h.parameters())
scalars = self.resid_lambdas.numel() + self.x0_lambdas.numel() + self.smear_gate.weight.numel() + self.smear_lambda.numel() + self.backout_lambda.numel()
total = wte + value_embeds + lm_head + transformer_matrices + scalars
assert total == sum(p.numel() for p in self.parameters()), "Parameter count mismatch"
return {
'wte': wte,
'value_embeds': value_embeds,
'lm_head': lm_head,
'transformer_matrices': transformer_matrices,
'scalars': scalars,
'total': total,
}
def setup_optimizer(self, unembedding_lr=0.004, embedding_lr=0.2, matrix_lr=0.02, weight_decay=0.0, scalar_lr=0.5):
model_dim = self.config.n_embd
ddp, rank, local_rank, world_size = get_dist_info()
# Separate out all parameters into groups
matrix_params = list(self.transformer.h.parameters())
value_embeds_params = list(self.value_embeds.parameters())
embedding_params = list(self.transformer.wte.parameters())
lm_head_params = list(self.lm_head.parameters())
resid_params = [self.resid_lambdas]
x0_params = [self.x0_lambdas]
smear_params = [self.smear_gate.weight, self.smear_lambda, self.backout_lambda]
assert len(list(self.parameters())) == len(matrix_params) + len(embedding_params) + len(lm_head_params) + len(value_embeds_params) + len(resid_params) + len(x0_params) + len(smear_params)
# Scale the LR for the AdamW parameters by ∝1/√dmodel (tuned for 768 dim model)
dmodel_lr_scale = (model_dim / 768) ** -0.5
print0(f"Scaling the LR for the AdamW parameters ∝1/√({model_dim}/768) = {dmodel_lr_scale:.6f}")
# Build param_groups with all required fields explicit
param_groups = [
# AdamW groups (embeddings, lm_head, scalars)
dict(kind='adamw', params=lm_head_params, lr=unembedding_lr * dmodel_lr_scale, betas=(0.8, 0.96), eps=1e-10, weight_decay=0.01),
dict(kind='adamw', params=embedding_params, lr=embedding_lr * dmodel_lr_scale, betas=(0.8, 0.995), eps=1e-10, weight_decay=0.001),
dict(kind='adamw', params=value_embeds_params, lr=embedding_lr * dmodel_lr_scale * 0.5, betas=(0.8, 0.995), eps=1e-10, weight_decay=0.01),
dict(kind='adamw', params=resid_params, lr=scalar_lr * 0.01, betas=(0.8, 0.95), eps=1e-10, weight_decay=0.05),
dict(kind='adamw', params=x0_params, lr=scalar_lr, betas=(0.96, 0.95), eps=1e-10, weight_decay=0.0), # higher beta1 for x0
dict(kind='adamw', params=smear_params, lr=0.2, betas=(0.8, 0.95), eps=1e-10, weight_decay=0.0),
]
# Muon groups (matrix params, grouped by shape for stacking)
for shape in sorted({p.shape for p in matrix_params}):
group_params = [p for p in matrix_params if p.shape == shape]
param_groups.append(dict(
kind='muon', params=group_params, lr=matrix_lr,
momentum=0.95, ns_steps=5, beta2=0.9, weight_decay=weight_decay,
))
Factory = DistMuonAdamW if ddp else MuonAdamW
optimizer = Factory(param_groups)
for group in optimizer.param_groups:
group["initial_lr"] = group["lr"]
return optimizer
def forward(self, idx, targets=None, kv_cache=None, loss_reduction='mean'):
B, T = idx.size()
# Grab the rotary embeddings for the current sequence length (they are of shape (1, seq_len, 1, head_dim/2))
assert T <= self.cos.size(1), f"Sequence length grew beyond the rotary embeddings cache: {T} > {self.cos.size(1)}"
assert idx.device == self.cos.device, f"Rotary embeddings and idx are on different devices: {idx.device} != {self.cos.device}"
assert self.cos.dtype == COMPUTE_DTYPE, f"Rotary embeddings must be in {COMPUTE_DTYPE}, got {self.cos.dtype}"
# if kv cache exists, we need to offset the rotary embeddings to the current position in the cache
T0 = 0 if kv_cache is None else kv_cache.get_pos()
cos_sin = self.cos[:, T0:T0+T], self.sin[:, T0:T0+T] # truncate cache to current sequence length
# Embed the tokens
x = self.transformer.wte(idx) # embed current token
x = x.to(COMPUTE_DTYPE) # ensure activations are in compute dtype (no-op usually, but active for fp16 code path)
x = norm(x)
# Smear: mix previous token's embedding into current position (cheap bigram info)
if kv_cache is None:
# Training / naive generate: full sequence available, use fast slice
assert T > 1, "Training forward pass should have T > 1"
gate = self.smear_lambda.to(x.dtype) * torch.sigmoid(self.smear_gate(x[:, 1:, :24]))
x = torch.cat([x[:, :1], x[:, 1:] + gate * x[:, :-1]], dim=1)
else:
# KV cache inference: read prev embedding from cache, store current for next step
x_pre_smear = kv_cache.prev_embedding
kv_cache.prev_embedding = x[:, -1:, :]
if T > 1:
# Prefill: apply smear to positions 1+, same as training
gate = self.smear_lambda.to(x.dtype) * torch.sigmoid(self.smear_gate(x[:, 1:, :24]))
x = torch.cat([x[:, :1], x[:, 1:] + gate * x[:, :-1]], dim=1)
elif x_pre_smear is not None:
# Decode: single token, use cached prev embedding
gate = self.smear_lambda.to(x.dtype) * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear
# Forward the trunk of the Transformer
x0 = x # save initial normalized embedding for x0 residual
n_layer = self.config.n_layer
backout_layer = n_layer // 2 # cache at halfway point
x_backout = None
for i, block in enumerate(self.transformer.h):
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0
ve = self.value_embeds[str(i)](idx).to(x.dtype) if str(i) in self.value_embeds else None
x = block(x, ve, cos_sin, self.window_sizes[i], kv_cache)
if i == backout_layer:
x_backout = x
# Subtract mid-layer residual to remove low-level features before logit projection
if x_backout is not None:
x = x - self.backout_lambda.to(x.dtype) * x_backout
x = norm(x)
# Forward the lm_head (compute logits)
softcap = 15 # smoothly cap the logits to the range [-softcap, softcap]
logits = self.lm_head(x) # (B, T, padded_vocab_size) <- very big tensor, large amount of memory
logits = logits[..., :self.config.vocab_size] # slice to remove padding
logits = logits.float() # switch to fp32 for logit softcap and loss computation
logits = softcap * torch.tanh(logits / softcap) # squash the logits
if targets is not None:
# training: given the targets, compute and return the loss
# TODO experiment with chunked cross-entropy?
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1, reduction=loss_reduction)
return loss
else:
# inference: just return the logits directly
return logits
@torch.inference_mode()
def generate(self, tokens, max_tokens, temperature=1.0, top_k=None, seed=42):
assert isinstance(tokens, list)
device = self.get_device()
rng = None
if temperature > 0:
rng = torch.Generator(device=device)
rng.manual_seed(seed)
ids = torch.tensor([tokens], dtype=torch.long, device=device) # add batch dim
for _ in range(max_tokens):
logits = self.forward(ids) # (B, T, vocab_size)
logits = logits[:, -1, :] # (B, vocab_size)
if top_k is not None and top_k > 0:
v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
logits[logits < v[:, [-1]]] = -float('Inf')
if temperature > 0:
logits = logits / temperature
probs = F.softmax(logits, dim=-1)
next_ids = torch.multinomial(probs, num_samples=1, generator=rng)
else:
next_ids = torch.argmax(logits, dim=-1, keepdim=True)
ids = torch.cat((ids, next_ids), dim=1)
token = next_ids.item()
yield token | --- +++ @@ -1,3 +1,16 @@+"""
+GPT model (rewrite, a lot simpler)
+Notable features:
+- rotary embeddings (and no positional embeddings)
+- QK norm
+- untied weights for token embedding and lm_head
+- relu^2 activation in MLP
+- norm after token embedding
+- no learnable params in rmsnorm
+- no bias in linear layers
+- Group-Query Attention (GQA) support for more efficient inference
+- Flash Attention 3 integration
+"""
from functools import partial
from dataclasses import dataclass
@@ -30,11 +43,15 @@ return F.rms_norm(x, (x.size(-1),)) # note that this will run in bf16, seems ok
class Linear(nn.Linear):
+ """nn.Linear that casts weights to match input dtype in forward.
+ Replaces autocast: master weights stay fp32 for optimizer precision,
+ but matmuls run in the activation dtype (typically bf16 from embeddings)."""
def forward(self, x):
return F.linear(x, self.weight.to(dtype=x.dtype))
def has_ve(layer_idx, n_layer):
+ """Returns True if GPT layer should have Value Embedding (alternating, last layer always included)."""
return layer_idx % 2 == (n_layer - 1) % 2
def apply_rotary_emb(x, cos, sin):
@@ -136,6 +153,11 @@
class GPT(nn.Module):
def __init__(self, config, pad_vocab_size_to=64):
+ """
+ NOTE a major footgun: this __init__ function runs in meta device context (!!)
+ Therefore, any calculations inside here are shapes and dtypes only, no actual data.
+ => We actually initialize all data (parameters, buffers, etc.) in init_weights() instead.
+ """
super().__init__()
self.config = config
# Compute per-layer window sizes for sliding window attention
@@ -178,6 +200,19 @@
@torch.no_grad()
def init_weights(self):
+ """
+ Initialize the full model in this one function for maximum clarity.
+
+ wte (embedding): normal, std=1.0
+ lm_head: normal, std=0.001
+ for each block:
+ attn.c_q: uniform, std=1/sqrt(n_embd)
+ attn.c_k: uniform, std=1/sqrt(n_embd)
+ attn.c_v: uniform, std=1/sqrt(n_embd)
+ attn.c_proj: zeros
+ mlp.c_fc: uniform, std=1/sqrt(n_embd)
+ mlp.c_proj: zeros
+ """
# Embedding and unembedding
torch.nn.init.normal_(self.transformer.wte.weight, mean=0.0, std=0.8)
@@ -243,6 +278,16 @@ return cos, sin
def _compute_window_sizes(self, config):
+ """
+ Compute per-layer window sizes for sliding window attention.
+
+ Returns list of (left, right) tuples for FA3's window_size parameter:
+ - left: how many tokens before current position to attend to (-1 = unlimited)
+ - right: how many tokens after current position to attend to (0 for causal)
+
+ Pattern string is tiled across layers. Final layer always gets L (full context).
+ Characters: L=long (full context), S=short (quarter context)
+ """
pattern = config.window_pattern.upper()
assert all(c in "SL" for c in pattern), f"Invalid window_pattern: {pattern}. Use only S and L."
# Map characters to window sizes
@@ -265,6 +310,17 @@ return self.transformer.wte.weight.device
def estimate_flops(self):
+ """
+ Return the estimated FLOPs per token for the model (forward + backward).
+ Each matmul weight parameter contributes 2 FLOPs (multiply *, accumulate +) in forward, and 2X that in backward => 2+4=6.
+ Cleanest explanation of this: https://medium.com/@dzmitrybahdanau/the-flops-calculus-of-language-model-training-3b19c1f025e4
+ On top of that, 12 * h * q * effective_seq_len accounts for key @ query matmul flops inside attention.
+ With sliding windows, effective_seq_len varies per layer (capped by window size).
+ Ref: https://arxiv.org/abs/2204.02311 (PaLM paper).
+ This is ~1% off from the exact formulas of Chinchilla paper, the difference is:
+ - Chinchilla counts the embedding layer as flops (? weird, it's just a lookup => we ignore)
+ - Chinchilla counts exp/sum/divide in attention softmax as flops (a little sus and very tiny => we ignore)
+ """
nparams = sum(p.numel() for p in self.parameters())
# Exclude non-matmul params: embeddings and per-layer scalars
value_embeds_numel = sum(ve.weight.numel() for ve in self.value_embeds.values())
@@ -282,6 +338,17 @@ return num_flops_per_token
def num_scaling_params(self):
+ """
+ Return detailed parameter counts for scaling law analysis.
+ Different papers use different conventions:
+ - Kaplan et al. excluded embedding parameters
+ - Chinchilla included all parameters
+ Ref: https://arxiv.org/abs/2203.15556 (Chinchilla paper)
+ Ref: https://arxiv.org/abs/2001.08361 (Kaplan et al. original scaling laws paper)
+
+ Returns a dict with counts for each parameter group, so downstream analysis
+ can experiment with which combination gives the cleanest scaling laws.
+ """
# Count each group separately (mirrors the grouping in setup_optimizers)
wte = sum(p.numel() for p in self.transformer.wte.parameters())
value_embeds = sum(p.numel() for p in self.value_embeds.parameters())
@@ -410,6 +477,12 @@
@torch.inference_mode()
def generate(self, tokens, max_tokens, temperature=1.0, top_k=None, seed=42):
+ """
+ Naive autoregressive streaming inference.
+ To make it super simple, let's assume:
+ - batch size is 1
+ - ids and the yielded tokens are simple Python lists and ints
+ """
assert isinstance(tokens, list)
device = self.get_device()
rng = None
@@ -431,4 +504,4 @@ next_ids = torch.argmax(logits, dim=-1, keepdim=True)
ids = torch.cat((ids, next_ids), dim=1)
token = next_ids.item()
- yield token+ yield token
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/gpt.py |
Generate docstrings with parameter types |
import torch
import torch.nn.functional as F
import signal
import warnings
from contextlib import contextmanager
from collections import deque
from nanochat.common import compute_init, autodetect_device_type
from nanochat.checkpoint_manager import load_model
# -----------------------------------------------------------------------------
# Calculator tool helpers
@contextmanager
def timeout(duration, formula):
def timeout_handler(signum, frame):
raise Exception(f"'{formula}': timed out after {duration} seconds")
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(duration)
yield
signal.alarm(0)
def eval_with_timeout(formula, max_time=3):
try:
with timeout(max_time, formula):
with warnings.catch_warnings():
warnings.simplefilter("ignore", SyntaxWarning)
return eval(formula, {"__builtins__": {}}, {})
except Exception as e:
signal.alarm(0)
# print(f"Warning: Failed to eval {formula}, exception: {e}") # it's ok ignore wrong calculator usage
return None
def use_calculator(expr):
# Remove commas from numbers
expr = expr.replace(",", "")
# Check if it's a pure math expression (old behavior)
if all([x in "0123456789*+-/.() " for x in expr]):
if "**" in expr: # disallow power operator
return None
return eval_with_timeout(expr)
# Check if it's a string operation we support
# Allow: strings (single/double quotes), .count(), letters, numbers, spaces, parens
allowed_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'\"()._ "
if not all([x in allowed_chars for x in expr]):
return None
# Disallow dangerous patterns
dangerous_patterns = ['__', 'import', 'exec', 'eval', 'compile', 'open', 'file',
'input', 'raw_input', 'globals', 'locals', 'vars', 'dir',
'getattr', 'setattr', 'delattr', 'hasattr']
expr_lower = expr.lower()
if any(pattern in expr_lower for pattern in dangerous_patterns):
return None
# Only allow .count() method for now (can expand later)
if '.count(' not in expr:
return None
# Evaluate with timeout
return eval_with_timeout(expr)
# -----------------------------------------------------------------------------
class KVCache:
def __init__(self, batch_size, num_heads, seq_len, head_dim, num_layers, device, dtype):
self.batch_size = batch_size
self.max_seq_len = seq_len
self.n_layers = num_layers
self.n_heads = num_heads
self.head_dim = head_dim
# Pre-allocate cache tensors: (n_layers, B, T, H, D)
self.k_cache = torch.zeros(num_layers, batch_size, seq_len, num_heads, head_dim, device=device, dtype=dtype)
self.v_cache = torch.zeros(num_layers, batch_size, seq_len, num_heads, head_dim, device=device, dtype=dtype)
# Current sequence length per batch element (FA3 needs int32)
self.cache_seqlens = torch.zeros(batch_size, dtype=torch.int32, device=device)
# Previous token's normalized embedding for smear (set by model forward pass)
self.prev_embedding = None
def reset(self):
self.cache_seqlens.zero_()
self.prev_embedding = None
def get_pos(self):
return self.cache_seqlens[0].item()
def get_layer_cache(self, layer_idx):
return self.k_cache[layer_idx], self.v_cache[layer_idx]
def advance(self, num_tokens):
self.cache_seqlens += num_tokens
def prefill(self, other):
assert self.get_pos() == 0, "Cannot prefill a non-empty KV cache"
assert self.n_layers == other.n_layers and self.n_heads == other.n_heads and self.head_dim == other.head_dim
assert self.max_seq_len >= other.max_seq_len
other_pos = other.get_pos()
self.k_cache[:, :, :other_pos, :, :] = other.k_cache[:, :, :other_pos, :, :]
self.v_cache[:, :, :other_pos, :, :] = other.v_cache[:, :, :other_pos, :, :]
self.cache_seqlens.fill_(other_pos)
# Copy smear state: expand batch=1 prev_embedding to num_samples
if other.prev_embedding is not None:
self.prev_embedding = other.prev_embedding.expand(self.batch_size, -1, -1).clone()
# -----------------------------------------------------------------------------
@torch.inference_mode()
def sample_next_token(logits, rng, temperature=1.0, top_k=None):
assert temperature >= 0.0, "temperature must be non-negative"
if temperature == 0.0:
return torch.argmax(logits, dim=-1, keepdim=True)
if top_k is not None and top_k > 0:
k = min(top_k, logits.size(-1))
vals, idx = torch.topk(logits, k, dim=-1)
vals = vals / temperature
probs = F.softmax(vals, dim=-1)
choice = torch.multinomial(probs, num_samples=1, generator=rng)
return idx.gather(1, choice)
else:
logits = logits / temperature
probs = F.softmax(logits, dim=-1)
return torch.multinomial(probs, num_samples=1, generator=rng)
# -----------------------------------------------------------------------------
class RowState:
# Per-row state tracking during generation
def __init__(self, current_tokens=None):
self.current_tokens = current_tokens or [] # Current token sequence for this row
self.forced_tokens = deque() # Queue of tokens to force inject
self.in_python_block = False # Whether we are inside a python block
self.python_expr_tokens = [] # Tokens of the current python expression
self.completed = False # Whether this row has completed generation
class Engine:
def __init__(self, model, tokenizer):
self.model = model
self.tokenizer = tokenizer # needed for tool use
@torch.inference_mode()
def generate(self, tokens, num_samples=1, max_tokens=None, temperature=1.0, top_k=None, seed=42):
assert isinstance(tokens, list) and isinstance(tokens[0], int), "expecting list of ints"
device = self.model.get_device()
# NOTE: setting the dtype here and in this way is an ugly hack.
# Currently the repo assumes that cuda -> bfloat16 and everything else -> float32.
# We need to know the dtype here to call __init__ on KVCache and pre-allocate its tensors.
# As a quick hack, we're making generate() function inherit and know about this repo-wise assumption.
# I think there has to be a bigger refactor to deal with device/dtype tracking across the codebase.
# In particular, the KVCache should allocate its tensors lazily
dtype = torch.bfloat16 if device.type == "cuda" else torch.float32
rng = torch.Generator(device=device)
rng.manual_seed(seed)
# Get the special tokens we need to coordinate the tool use state machine
get_special = lambda s: self.tokenizer.encode_special(s)
python_start = get_special("<|python_start|>")
python_end = get_special("<|python_end|>")
output_start = get_special("<|output_start|>")
output_end = get_special("<|output_end|>")
assistant_end = get_special("<|assistant_end|>") # if sampled, ends row
bos = self.tokenizer.get_bos_token_id() # if sampled, ends row
# 1) Run a batch 1 prefill of the prompt tokens
m = self.model.config
kv_model_kwargs = {"num_heads": m.n_kv_head, "head_dim": m.n_embd // m.n_head, "num_layers": m.n_layer}
kv_cache_prefill = KVCache(
batch_size=1,
seq_len=len(tokens),
device=device,
dtype=dtype,
**kv_model_kwargs,
)
ids = torch.tensor([tokens], dtype=torch.long, device=device)
logits = self.model.forward(ids, kv_cache=kv_cache_prefill)
logits = logits[:, -1, :].expand(num_samples, -1) # (num_samples, vocab_size)
# 2) Replicate the KV cache for each sample/row
kv_length_hint = (len(tokens) + max_tokens) if max_tokens is not None else self.model.config.sequence_len
kv_cache_decode = KVCache(
batch_size=num_samples,
seq_len=kv_length_hint,
device=device,
dtype=dtype,
**kv_model_kwargs,
)
kv_cache_decode.prefill(kv_cache_prefill)
del kv_cache_prefill # no need to keep this memory around
# 3) Initialize states for each sample
row_states = [RowState(tokens.copy()) for _ in range(num_samples)]
# 4) Main generation loop
num_generated = 0
while True:
# Stop condition: we've reached max tokens
if max_tokens is not None and num_generated >= max_tokens:
break
# Stop condition: all rows are completed
if all(state.completed for state in row_states):
break
# Sample the next token for each row
next_ids = sample_next_token(logits, rng, temperature, top_k) # (B, 1)
sampled_tokens = next_ids[:, 0].tolist()
# Process each row: choose the next token, update state, optional tool use
token_column = [] # contains the next token id along each row
token_masks = [] # contains the mask (was it sampled (1) or forced (0)?) along each row
for i, state in enumerate(row_states):
# Select the next token in this row
is_forced = len(state.forced_tokens) > 0 # are there tokens waiting to be forced in deque?
token_masks.append(0 if is_forced else 1) # mask is 0 if forced, 1 if sampled
next_token = state.forced_tokens.popleft() if is_forced else sampled_tokens[i]
token_column.append(next_token)
# Update the state of this row to include the next token
state.current_tokens.append(next_token)
# On <|assistant_end|> or <|bos|>, mark the row as completed
if next_token == assistant_end or next_token == bos:
state.completed = True
# Handle tool logic
if next_token == python_start:
state.in_python_block = True
state.python_expr_tokens = []
elif next_token == python_end and state.in_python_block:
state.in_python_block = False
if state.python_expr_tokens:
expr = self.tokenizer.decode(state.python_expr_tokens)
result = use_calculator(expr)
if result is not None:
result_tokens = self.tokenizer.encode(str(result))
state.forced_tokens.append(output_start)
state.forced_tokens.extend(result_tokens)
state.forced_tokens.append(output_end)
state.python_expr_tokens = []
elif state.in_python_block:
state.python_expr_tokens.append(next_token)
# Yield the token column
yield token_column, token_masks
num_generated += 1
# Prepare logits for next iteration
ids = torch.tensor(token_column, dtype=torch.long, device=device).unsqueeze(1)
logits = self.model.forward(ids, kv_cache=kv_cache_decode)[:, -1, :] # (B, vocab_size)
def generate_batch(self, tokens, num_samples=1, **kwargs):
assistant_end = self.tokenizer.encode_special("<|assistant_end|>")
bos = self.tokenizer.get_bos_token_id()
results = [tokens.copy() for _ in range(num_samples)]
masks = [[0] * len(tokens) for _ in range(num_samples)]
completed = [False] * num_samples
for token_column, token_masks in self.generate(tokens, num_samples, **kwargs):
for i, (token, mask) in enumerate(zip(token_column, token_masks)):
if not completed[i]:
if token == assistant_end or token == bos:
completed[i] = True
else:
results[i].append(token)
masks[i].append(mask)
# Stop if all rows are completed
if all(completed):
break
return results, masks
if __name__ == "__main__":
"""
Quick inline test to make sure that the naive/slow model.generate function
is equivalent to the faster Engine.generate function here.
"""
import time
# init compute
device_type = autodetect_device_type()
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
# load the model and tokenizer
model, tokenizer, meta = load_model("base", device, phase="eval")
bos_token_id = tokenizer.get_bos_token_id()
# common hyperparameters
kwargs = dict(max_tokens=64, temperature=0.0)
# set the starting prompt
prompt_tokens = tokenizer.encode("The chemical formula of water is", prepend=bos_token_id)
# generate the reference sequence using the model.generate() function
generated_tokens = []
torch.cuda.synchronize()
t0 = time.time()
stream = model.generate(prompt_tokens, **kwargs)
for token in stream:
generated_tokens.append(token)
chunk = tokenizer.decode([token])
print(chunk, end="", flush=True)
print()
torch.cuda.synchronize()
t1 = time.time()
print(f"Reference time: {t1 - t0:.2f}s")
reference_ids = generated_tokens
# generate tokens with Engine
generated_tokens = []
engine = Engine(model, tokenizer)
stream = engine.generate(prompt_tokens, num_samples=1, **kwargs) # note: runs in fp32
torch.cuda.synchronize()
t0 = time.time()
for token_column, token_masks in stream:
token = token_column[0] # only print out the first row
generated_tokens.append(token)
chunk = tokenizer.decode([token])
print(chunk, end="", flush=True)
print()
torch.cuda.synchronize()
t1 = time.time()
print(f"Engine time: {t1 - t0:.2f}s")
# compare the two sequences
for i in range(len(reference_ids)):
if reference_ids[i] != generated_tokens[i]:
print(f"Mismatch at {i}: {reference_ids[i]} != {generated_tokens[i]}")
break
print(f"Match: {reference_ids == generated_tokens}") | --- +++ @@ -1,3 +1,15 @@+"""
+Engine for efficient inference of our models.
+
+Everything works around token sequences:
+- The user can send token sequences to the engine
+- The engine returns the next token
+
+Notes:
+- The engine knows nothing about tokenization, it's purely token id sequences.
+
+The whole thing is made as efficient as possible.
+"""
import torch
import torch.nn.functional as F
@@ -32,6 +44,10 @@ return None
def use_calculator(expr):
+ """
+ Evaluate a Python expression safely.
+ Supports both math expressions and string operations like .count()
+ """
# Remove commas from numbers
expr = expr.replace(",", "")
@@ -64,6 +80,14 @@
# -----------------------------------------------------------------------------
class KVCache:
+ """
+ KV Cache designed for Flash Attention 3's flash_attn_with_kvcache API.
+
+ Key differences from FA2-style cache:
+ - Tensors are (B, T, H, D) not (B, H, T, D)
+ - FA3 updates the cache in-place during flash_attn_with_kvcache
+ - Position tracked per batch element via cache_seqlens tensor
+ """
def __init__(self, batch_size, num_heads, seq_len, head_dim, num_layers, device, dtype):
self.batch_size = batch_size
@@ -80,19 +104,27 @@ self.prev_embedding = None
def reset(self):
+ """Reset cache to empty state."""
self.cache_seqlens.zero_()
self.prev_embedding = None
def get_pos(self):
+ """Get current position (assumes all batch elements at same position)."""
return self.cache_seqlens[0].item()
def get_layer_cache(self, layer_idx):
+ """Return (k_cache, v_cache) views for a specific layer."""
return self.k_cache[layer_idx], self.v_cache[layer_idx]
def advance(self, num_tokens):
+ """Advance the cache position by num_tokens."""
self.cache_seqlens += num_tokens
def prefill(self, other):
+ """
+ Copy cached KV from another cache into this one.
+ Used when we do batch=1 prefill and then want to generate multiple samples in parallel.
+ """
assert self.get_pos() == 0, "Cannot prefill a non-empty KV cache"
assert self.n_layers == other.n_layers and self.n_heads == other.n_heads and self.head_dim == other.head_dim
assert self.max_seq_len >= other.max_seq_len
@@ -107,6 +139,7 @@ # -----------------------------------------------------------------------------
@torch.inference_mode()
def sample_next_token(logits, rng, temperature=1.0, top_k=None):
+ """Sample a single next token from given logits of shape (B, vocab_size). Returns (B, 1)."""
assert temperature >= 0.0, "temperature must be non-negative"
if temperature == 0.0:
return torch.argmax(logits, dim=-1, keepdim=True)
@@ -141,6 +174,7 @@
@torch.inference_mode()
def generate(self, tokens, num_samples=1, max_tokens=None, temperature=1.0, top_k=None, seed=42):
+ """Same as generate, but does single prefill and then clones the KV cache."""
assert isinstance(tokens, list) and isinstance(tokens[0], int), "expecting list of ints"
device = self.model.get_device()
# NOTE: setting the dtype here and in this way is an ugly hack.
@@ -246,6 +280,11 @@ logits = self.model.forward(ids, kv_cache=kv_cache_decode)[:, -1, :] # (B, vocab_size)
def generate_batch(self, tokens, num_samples=1, **kwargs):
+ """
+ Non-streaming batch generation that just returns the final token sequences.
+ Returns a list of token sequences (list of lists of ints).
+ Terminal tokens (assistant_end, bos) are not included in the results.
+ """
assistant_end = self.tokenizer.encode_special("<|assistant_end|>")
bos = self.tokenizer.get_bos_token_id()
results = [tokens.copy() for _ in range(num_samples)]
@@ -315,4 +354,4 @@ if reference_ids[i] != generated_tokens[i]:
print(f"Mismatch at {i}: {reference_ids[i]} != {generated_tokens[i]}")
break
- print(f"Match: {reference_ids == generated_tokens}")+ print(f"Match: {reference_ids == generated_tokens}")
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/engine.py |
Write docstrings describing each step |
import torch
import torch.nn as nn
from nanochat.common import COMPUTE_DTYPE
# Avoid division by zero when computing scale from an all-zeros tensor
EPS = 1e-12
@torch.no_grad()
def _to_fp8(x, fp8_dtype):
fp8_max = torch.finfo(fp8_dtype).max
# Compute the max absolute value across the entire tensor
amax = x.float().abs().max()
# Scale maps [0, amax] -> [0, fp8_max]. Use float64 for the division to
# ensure consistent numerics between torch.compile and eager mode.
# (torchao does the same upcast — without it, compile/eager can diverge)
scale = fp8_max / amax.double().clamp(min=EPS)
scale = scale.float()
# Quantize: scale into FP8 range, saturate (clamp prevents overflow when
# casting — PyTorch's default is to wrap, not saturate), then cast to FP8
x_scaled = x.float() * scale
x_clamped = x_scaled.clamp(-fp8_max, fp8_max)
x_fp8 = x_clamped.to(fp8_dtype)
# _scaled_mm expects the *inverse* of our scale (it multiplies by this to
# convert FP8 values back to the original range during the matmul)
inv_scale = scale.reciprocal()
return x_fp8, inv_scale
def _to_col_major(x):
return x.t().contiguous().t()
# allow_in_graph tells torch.compile to treat this as an opaque operation —
# dynamo won't try to decompose it into smaller ops. See the module docstring
# for how this differs from torchao's tensor subclass approach.
@torch._dynamo.allow_in_graph
class _Float8Matmul(torch.autograd.Function):
@staticmethod
def forward(ctx, input_2d, weight):
# Quantize both operands to e4m3 (higher precision format)
input_fp8, input_inv = _to_fp8(input_2d, torch.float8_e4m3fn)
weight_fp8, weight_inv = _to_fp8(weight, torch.float8_e4m3fn)
ctx.save_for_backward(input_fp8, input_inv, weight_fp8, weight_inv)
# output = input @ weight.T
# input_fp8 is [B, K] contiguous = row-major (good for first arg)
# weight_fp8 is [N, K] contiguous, so weight_fp8.t() is [K, N] with
# strides (1, K) = column-major (good for second arg, no copy needed!)
output = torch._scaled_mm(
input_fp8,
weight_fp8.t(),
scale_a=input_inv,
scale_b=weight_inv,
out_dtype=input_2d.dtype,
# use_fast_accum=True accumulates the dot products in lower precision.
# Slightly less accurate but measurably faster. Standard practice for
# the forward pass; we use False in backward for more precise gradients.
use_fast_accum=True,
)
return output
@staticmethod
def backward(ctx, grad_output):
in_fp8, in_inv, w_fp8, w_inv = ctx.saved_tensors
# === GEMM 1: grad_input = grad_output @ weight ===
# Shapes: [B, N] @ [N, K] -> [B, K]
# Gradients use e5m2 (wider range), weights use e4m3 (higher precision)
go_fp8, go_inv = _to_fp8(grad_output, torch.float8_e5m2)
# go_fp8 is [B, N] contiguous = row-major, good for first arg
# w_fp8 is [N, K] contiguous = row-major, need column-major for second arg
w_col = _to_col_major(w_fp8)
grad_input = torch._scaled_mm(
go_fp8,
w_col,
scale_a=go_inv,
scale_b=w_inv,
out_dtype=grad_output.dtype,
use_fast_accum=False,
)
# === GEMM 2: grad_weight = grad_output.T @ input ===
# Shapes: [N, B] @ [B, K] -> [N, K]
# go_fp8 is [B, N] contiguous, we need go.T = [N, B] as first arg.
# Transposing gives column-major, but first arg needs row-major,
# so we must call .contiguous() to physically rearrange the memory.
go_T = go_fp8.t().contiguous() # [N, B] row-major
in_col = _to_col_major(in_fp8) # [B, K] column-major
grad_weight = torch._scaled_mm(
go_T,
in_col,
scale_a=go_inv,
scale_b=in_inv,
out_dtype=grad_output.dtype,
use_fast_accum=False,
)
return grad_input, grad_weight
class Float8Linear(nn.Linear):
def forward(self, input):
# Cast input to COMPUTE_DTYPE (typically bf16) since _scaled_mm expects
# reduced precision input, and we no longer rely on autocast to do this.
input = input.to(COMPUTE_DTYPE)
# _scaled_mm only works on 2D tensors, so flatten batch dimensions
orig_shape = input.shape
input_2d = input.reshape(-1, orig_shape[-1])
output = _Float8Matmul.apply(input_2d, self.weight)
output = output.reshape(*orig_shape[:-1], output.shape[-1])
if self.bias is not None:
output = output + self.bias.to(output.dtype)
return output
@classmethod
def from_float(cls, mod):
with torch.device("meta"):
new_mod = cls(mod.in_features, mod.out_features, bias=False)
new_mod.weight = mod.weight
new_mod.bias = mod.bias
return new_mod
class Float8LinearConfig:
@staticmethod
def from_recipe_name(recipe_name):
if recipe_name != "tensorwise":
raise ValueError(
f"Only 'tensorwise' recipe is supported, got '{recipe_name}'. "
f"Rowwise/axiswise recipes require the full torchao library."
)
return Float8LinearConfig()
def convert_to_float8_training(module, *, config=None, module_filter_fn=None):
def _convert(mod, prefix=""):
for name, child in mod.named_children():
fqn = f"{prefix}.{name}" if prefix else name
_convert(child, fqn)
if isinstance(child, nn.Linear) and not isinstance(child, Float8Linear):
if module_filter_fn is None or module_filter_fn(child, fqn):
setattr(mod, name, Float8Linear.from_float(child))
_convert(module)
return module | --- +++ @@ -1,3 +1,73 @@+"""Minimal FP8 training for nanochat — tensorwise dynamic scaling only.
+
+Drop-in replacement for torchao's Float8Linear (~2000 lines) with ~150 lines.
+We only need the "tensorwise" recipe (one scalar scale per tensor), not the full
+generality of torchao (rowwise scaling, FSDP float8 all-gather, DTensor, tensor
+subclass dispatch tables, etc.)
+
+How FP8 training works
+======================
+A standard Linear layer does one matmul in forward and two in backward:
+ forward: output = input @ weight.T
+ backward: grad_input = grad_output @ weight
+ grad_weight= grad_output.T @ input
+
+FP8 training wraps each of these three matmuls with:
+ 1. Compute scale = FP8_MAX / max(|tensor|) for each operand
+ 2. Quantize: fp8_tensor = clamp(tensor * scale, -FP8_MAX, FP8_MAX).to(fp8)
+ 3. Matmul via torch._scaled_mm (cuBLAS FP8 kernel, ~2x faster than bf16)
+ 4. Dequantize: _scaled_mm handles this internally using the inverse scales
+
+The key insight: torch._scaled_mm and the float8 dtypes are PyTorch built-ins.
+torchao is just orchestration around these primitives. We can call them directly.
+
+FP8 dtype choice
+================
+There are two FP8 formats. We use both, following the standard convention:
+ - float8_e4m3fn: 4-bit exponent, 3-bit mantissa, range [-448, 448]
+ Higher precision (more mantissa bits), used for input and weight.
+ - float8_e5m2: 5-bit exponent, 2-bit mantissa, range [-57344, 57344]
+ Wider range (more exponent bits), used for gradients which can be large.
+
+torch._scaled_mm layout requirements
+=====================================
+The cuBLAS FP8 kernel requires specific memory layouts:
+ - First argument (A): must be row-major (contiguous)
+ - Second argument (B): must be column-major (B.t().contiguous().t())
+If B is obtained by transposing a contiguous tensor (e.g. weight.t()), it is
+already column-major — no copy needed. Otherwise we use _to_col_major().
+
+How this differs from torchao's approach
+========================================
+torchao uses a "tensor subclass" architecture: Float8TrainingTensor is a subclass
+of torch.Tensor that bundles FP8 data + scale + metadata. It implements
+__torch_dispatch__ with a dispatch table that intercepts every aten op (mm, t,
+reshape, clone, ...) and handles it in FP8-aware fashion. When you call
+ output = input @ weight.T
+the @ operator dispatches to aten.mm, which gets intercepted and routed to
+torch._scaled_mm behind the scenes. This is ~2000 lines of code because you need
+a handler for every tensor operation that might touch an FP8 tensor.
+
+We take a simpler approach: a single autograd.Function (_Float8Matmul) that takes
+full-precision inputs, quantizes to FP8 internally, calls _scaled_mm, and returns
+full-precision outputs. Marked @allow_in_graph so torch.compile treats it as one
+opaque node rather than trying to trace inside.
+
+The trade-off is in how torch.compile sees the two approaches:
+ - torchao: compile decomposes the tensor subclass (via __tensor_flatten__) and
+ sees every individual op (amax, scale, cast, _scaled_mm) as separate graph
+ nodes. Inductor can fuse these with surrounding operations (e.g. fuse the
+ amax computation with the preceding layer's activation function).
+ - ours: compile sees a single opaque call. It can optimize everything around
+ the FP8 linear (attention, norms, etc.) but cannot fuse across the boundary.
+
+Both call the exact same cuBLAS _scaled_mm kernel — the GPU matmul is identical.
+The difference is only in the "glue" ops (amax, scale, cast) which are tiny
+compared to the matmul. In practice this means our version is slightly faster
+(less compilation overhead, no tensor subclass dispatch cost) but can produce
+subtly different floating-point rounding paths under torch.compile, since Inductor
+generates a different graph. Numerics are bitwise identical in eager mode.
+"""
import torch
import torch.nn as nn
@@ -10,6 +80,14 @@
@torch.no_grad()
def _to_fp8(x, fp8_dtype):
+ """Dynamically quantize a tensor to FP8 using tensorwise scaling.
+
+ "Tensorwise" means one scalar scale for the entire tensor (as opposed to
+ "rowwise" which computes a separate scale per row). Tensorwise is faster
+ because cuBLAS handles the scaling; rowwise needs the CUTLASS kernel.
+
+ Returns (fp8_data, inverse_scale) for use with torch._scaled_mm.
+ """
fp8_max = torch.finfo(fp8_dtype).max
# Compute the max absolute value across the entire tensor
amax = x.float().abs().max()
@@ -30,6 +108,13 @@
def _to_col_major(x):
+ """Rearrange a 2D tensor's memory to column-major layout.
+
+ torch._scaled_mm requires its second operand in column-major layout.
+ The trick: transpose -> contiguous (forces a copy in transposed order)
+ -> transpose back. The result has the same logical shape but column-major
+ strides, e.g. a [M, N] tensor gets strides (1, M) instead of (N, 1).
+ """
return x.t().contiguous().t()
@@ -38,6 +123,11 @@ # for how this differs from torchao's tensor subclass approach.
@torch._dynamo.allow_in_graph
class _Float8Matmul(torch.autograd.Function):
+ """Custom autograd for the three FP8 GEMMs of a Linear layer.
+
+ The forward quantizes input and weight to FP8 and saves
+ the quantized tensors + scales for backward.
+ """
@staticmethod
def forward(ctx, input_2d, weight):
@@ -103,6 +193,11 @@
class Float8Linear(nn.Linear):
+ """Drop-in nn.Linear replacement that does FP8 compute.
+
+ Weights and biases remain in their original precision (e.g. fp32/bf16).
+ Only the matmul is performed in FP8 via the _Float8Matmul autograd function.
+ """
def forward(self, input):
# Cast input to COMPUTE_DTYPE (typically bf16) since _scaled_mm expects
@@ -119,6 +214,12 @@
@classmethod
def from_float(cls, mod):
+ """Create Float8Linear from nn.Linear, sharing the same weight and bias.
+
+ Uses meta device to avoid allocating a temporary weight tensor — we
+ create the module shell on meta (shapes/dtypes only, no memory), then
+ point .weight and .bias to the original module's parameters.
+ """
with torch.device("meta"):
new_mod = cls(mod.in_features, mod.out_features, bias=False)
new_mod.weight = mod.weight
@@ -127,6 +228,7 @@
class Float8LinearConfig:
+ """Minimal config matching torchao's API. Only tensorwise recipe is supported."""
@staticmethod
def from_recipe_name(recipe_name):
@@ -139,6 +241,19 @@
def convert_to_float8_training(module, *, config=None, module_filter_fn=None):
+ """Replace nn.Linear layers with Float8Linear throughout a module.
+
+ Walks the module tree in post-order (children before parents) and swaps
+ each nn.Linear that passes the optional filter. The new Float8Linear shares
+ the original weight and bias tensors — no copies, no extra memory.
+
+ Args:
+ module: Root module to convert.
+ config: Float8LinearConfig (accepted for API compat, only tensorwise supported).
+ module_filter_fn: Optional filter(module, fqn) -> bool. Only matching Linears
+ are converted. Common use: skip layers with dims not divisible by 16
+ (hardware requirement for FP8 matmuls on H100).
+ """
def _convert(mod, prefix=""):
for name, child in mod.named_children():
fqn = f"{prefix}.{name}" if prefix else name
@@ -148,4 +263,4 @@ setattr(mod, name, Float8Linear.from_float(child))
_convert(module)
- return module+ return module
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/fp8.py |
Fill in missing docstrings in my code |
import os
import copy
from functools import lru_cache
SPECIAL_TOKENS = [
# every document begins with the Beginning of Sequence (BOS) token that delimits documents
"<|bos|>",
# tokens below are only used during finetuning to render Conversations into token ids
"<|user_start|>", # user messages
"<|user_end|>",
"<|assistant_start|>", # assistant messages
"<|assistant_end|>",
"<|python_start|>", # assistant invokes python REPL tool
"<|python_end|>",
"<|output_start|>", # python REPL outputs back to assistant
"<|output_end|>",
]
# NOTE: this split pattern deviates from GPT-4 in that we use \p{N}{1,2} instead of \p{N}{1,3}
# I did this because I didn't want to "waste" too many tokens on numbers for smaller vocab sizes.
# I verified that 2 is the sweet spot for vocab size of 32K. 1 is a bit worse, 3 was worse still.
SPLIT_PATTERN = r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}+|\p{N}{1,2}| ?[^\s\p{L}\p{N}]++[\r\n]*|\s*[\r\n]|\s+(?!\S)|\s+"""
# -----------------------------------------------------------------------------
# Generic GPT-4-style tokenizer based on HuggingFace Tokenizer
from tokenizers import Tokenizer as HFTokenizer
from tokenizers import pre_tokenizers, decoders, Regex
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
class HuggingFaceTokenizer:
def __init__(self, tokenizer):
self.tokenizer = tokenizer
@classmethod
def from_pretrained(cls, hf_path):
# init from a HuggingFace pretrained tokenizer (e.g. "gpt2")
tokenizer = HFTokenizer.from_pretrained(hf_path)
return cls(tokenizer)
@classmethod
def from_directory(cls, tokenizer_dir):
# init from a local directory on disk (e.g. "out/tokenizer")
tokenizer_path = os.path.join(tokenizer_dir, "tokenizer.json")
tokenizer = HFTokenizer.from_file(tokenizer_path)
return cls(tokenizer)
@classmethod
def train_from_iterator(cls, text_iterator, vocab_size):
# train from an iterator of text
# Configure the HuggingFace Tokenizer
tokenizer = HFTokenizer(BPE(
byte_fallback=True, # needed!
unk_token=None,
fuse_unk=False,
))
# Normalizer: None
tokenizer.normalizer = None
# Pre-tokenizer: GPT-4 style
# the regex pattern used by GPT-4 to split text into groups before BPE
# NOTE: The pattern was changed from \p{N}{1,3} to \p{N}{1,2} because I suspect it is harmful to
# very small models and smaller vocab sizes, because it is a little bit wasteful in the token space.
# (but I haven't validated this! TODO)
gpt4_split_regex = Regex(SPLIT_PATTERN) # huggingface demands that you wrap it in Regex!!
tokenizer.pre_tokenizer = pre_tokenizers.Sequence([
pre_tokenizers.Split(pattern=gpt4_split_regex, behavior="isolated", invert=False),
pre_tokenizers.ByteLevel(add_prefix_space=False, use_regex=False)
])
# Decoder: ByteLevel (it pairs together with the ByteLevel pre-tokenizer)
tokenizer.decoder = decoders.ByteLevel()
# Post-processor: None
tokenizer.post_processor = None
# Trainer: BPE
trainer = BpeTrainer(
vocab_size=vocab_size,
show_progress=True,
min_frequency=0, # no minimum frequency
initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
special_tokens=SPECIAL_TOKENS,
)
# Kick off the training
tokenizer.train_from_iterator(text_iterator, trainer)
return cls(tokenizer)
def get_vocab_size(self):
return self.tokenizer.get_vocab_size()
def get_special_tokens(self):
special_tokens_map = self.tokenizer.get_added_tokens_decoder()
special_tokens = [w.content for w in special_tokens_map.values()]
return special_tokens
def id_to_token(self, id):
return self.tokenizer.id_to_token(id)
def _encode_one(self, text, prepend=None, append=None, num_threads=None):
# encode a single string
# prepend/append can be either a string of a special token or a token id directly.
# num_threads is ignored (only used by the nanochat Tokenizer for parallel encoding)
assert isinstance(text, str)
ids = []
if prepend is not None:
prepend_id = prepend if isinstance(prepend, int) else self.encode_special(prepend)
ids.append(prepend_id)
ids.extend(self.tokenizer.encode(text, add_special_tokens=False).ids)
if append is not None:
append_id = append if isinstance(append, int) else self.encode_special(append)
ids.append(append_id)
return ids
def encode_special(self, text):
# encode a single special token via exact match
return self.tokenizer.token_to_id(text)
def get_bos_token_id(self):
# Different HuggingFace models use different BOS tokens and there is little consistency
# 1) attempt to find a <|bos|> token
bos = self.encode_special("<|bos|>")
# 2) if that fails, attempt to find a <|endoftext|> token (e.g. GPT-2 models)
if bos is None:
bos = self.encode_special("<|endoftext|>")
# 3) if these fail, it's better to crash than to silently return None
assert bos is not None, "Failed to find BOS token in tokenizer"
return bos
def encode(self, text, *args, **kwargs):
if isinstance(text, str):
return self._encode_one(text, *args, **kwargs)
elif isinstance(text, list):
return [self._encode_one(t, *args, **kwargs) for t in text]
else:
raise ValueError(f"Invalid input type: {type(text)}")
def __call__(self, *args, **kwargs):
return self.encode(*args, **kwargs)
def decode(self, ids):
return self.tokenizer.decode(ids, skip_special_tokens=False)
def save(self, tokenizer_dir):
# save the tokenizer to disk
os.makedirs(tokenizer_dir, exist_ok=True)
tokenizer_path = os.path.join(tokenizer_dir, "tokenizer.json")
self.tokenizer.save(tokenizer_path)
print(f"Saved tokenizer to {tokenizer_path}")
# -----------------------------------------------------------------------------
# Tokenizer based on rustbpe + tiktoken combo
import pickle
import rustbpe
import tiktoken
class RustBPETokenizer:
def __init__(self, enc, bos_token):
self.enc = enc
self.bos_token_id = self.encode_special(bos_token)
@classmethod
def train_from_iterator(cls, text_iterator, vocab_size):
# 1) train using rustbpe
tokenizer = rustbpe.Tokenizer()
# the special tokens are inserted later in __init__, we don't train them here
vocab_size_no_special = vocab_size - len(SPECIAL_TOKENS)
assert vocab_size_no_special >= 256, f"vocab_size_no_special must be at least 256, got {vocab_size_no_special}"
tokenizer.train_from_iterator(text_iterator, vocab_size_no_special, pattern=SPLIT_PATTERN)
# 2) construct the associated tiktoken encoding for inference
pattern = tokenizer.get_pattern()
mergeable_ranks_list = tokenizer.get_mergeable_ranks()
mergeable_ranks = {bytes(k): v for k, v in mergeable_ranks_list}
tokens_offset = len(mergeable_ranks)
special_tokens = {name: tokens_offset + i for i, name in enumerate(SPECIAL_TOKENS)}
enc = tiktoken.Encoding(
name="rustbpe",
pat_str=pattern,
mergeable_ranks=mergeable_ranks, # dict[bytes, int] (token bytes -> merge priority rank)
special_tokens=special_tokens, # dict[str, int] (special token name -> token id)
)
return cls(enc, "<|bos|>")
@classmethod
def from_directory(cls, tokenizer_dir):
pickle_path = os.path.join(tokenizer_dir, "tokenizer.pkl")
with open(pickle_path, "rb") as f:
enc = pickle.load(f)
return cls(enc, "<|bos|>")
@classmethod
def from_pretrained(cls, tiktoken_name):
# https://github.com/openai/tiktoken/blob/eedc8563/tiktoken_ext/openai_public.py
enc = tiktoken.get_encoding(tiktoken_name)
# tiktoken calls the special document delimiter token "<|endoftext|>"
# yes this is confusing because this token is almost always PREPENDED to the beginning of the document
# it most often is used to signal the start of a new sequence to the LLM during inference etc.
# so in nanoChat we always use "<|bos|>" short for "beginning of sequence", but historically it is often called "<|endoftext|>".
return cls(enc, "<|endoftext|>")
def get_vocab_size(self):
return self.enc.n_vocab
def get_special_tokens(self):
return self.enc.special_tokens_set
def id_to_token(self, id):
return self.enc.decode([id])
@lru_cache(maxsize=32)
def encode_special(self, text):
return self.enc.encode_single_token(text)
def get_bos_token_id(self):
return self.bos_token_id
def encode(self, text, prepend=None, append=None, num_threads=8):
# text can be either a string or a list of strings
if prepend is not None:
prepend_id = prepend if isinstance(prepend, int) else self.encode_special(prepend)
if append is not None:
append_id = append if isinstance(append, int) else self.encode_special(append)
if isinstance(text, str):
ids = self.enc.encode_ordinary(text)
if prepend is not None:
ids.insert(0, prepend_id) # TODO: slightly inefficient here? :( hmm
if append is not None:
ids.append(append_id)
elif isinstance(text, list):
ids = self.enc.encode_ordinary_batch(text, num_threads=num_threads)
if prepend is not None:
for ids_row in ids:
ids_row.insert(0, prepend_id) # TODO: same
if append is not None:
for ids_row in ids:
ids_row.append(append_id)
else:
raise ValueError(f"Invalid input type: {type(text)}")
return ids
def __call__(self, *args, **kwargs):
return self.encode(*args, **kwargs)
def decode(self, ids):
return self.enc.decode(ids)
def save(self, tokenizer_dir):
# save the encoding object to disk
os.makedirs(tokenizer_dir, exist_ok=True)
pickle_path = os.path.join(tokenizer_dir, "tokenizer.pkl")
with open(pickle_path, "wb") as f:
pickle.dump(self.enc, f)
print(f"Saved tokenizer encoding to {pickle_path}")
def render_conversation(self, conversation, max_tokens=2048):
# ids, masks that we will return and a helper function to help build them up.
ids, mask = [], []
def add_tokens(token_ids, mask_val):
if isinstance(token_ids, int):
token_ids = [token_ids]
ids.extend(token_ids)
mask.extend([mask_val] * len(token_ids))
# sometimes the first message is a system message...
# => just merge it with the second (user) message
if conversation["messages"][0]["role"] == "system":
# some conversation surgery is necessary here for now...
conversation = copy.deepcopy(conversation) # avoid mutating the original
messages = conversation["messages"]
assert messages[1]["role"] == "user", "System message must be followed by a user message"
messages[1]["content"] = messages[0]["content"] + "\n\n" + messages[1]["content"]
messages = messages[1:]
else:
messages = conversation["messages"]
assert len(messages) >= 1, f"Conversation has less than 1 message: {messages}"
# fetch all the special tokens we need
bos = self.get_bos_token_id()
user_start, user_end = self.encode_special("<|user_start|>"), self.encode_special("<|user_end|>")
assistant_start, assistant_end = self.encode_special("<|assistant_start|>"), self.encode_special("<|assistant_end|>")
python_start, python_end = self.encode_special("<|python_start|>"), self.encode_special("<|python_end|>")
output_start, output_end = self.encode_special("<|output_start|>"), self.encode_special("<|output_end|>")
# now we can tokenize the conversation
add_tokens(bos, 0)
for i, message in enumerate(messages):
# some sanity checking here around assumptions, to prevent footguns
must_be_from = "user" if i % 2 == 0 else "assistant"
assert message["role"] == must_be_from, f"Message {i} is from {message['role']} but should be from {must_be_from}"
# content can be either a simple string or a list of parts (e.g. containing tool calls)
content = message["content"]
if message["role"] == "user":
assert isinstance(content, str), "User messages are simply expected to be strings"
value_ids = self.encode(content)
add_tokens(user_start, 0)
add_tokens(value_ids, 0)
add_tokens(user_end, 0)
elif message["role"] == "assistant":
add_tokens(assistant_start, 0)
if isinstance(content, str):
# simple string => simply add the tokens
value_ids = self.encode(content)
add_tokens(value_ids, 1)
elif isinstance(content, list):
for part in content:
value_ids = self.encode(part["text"])
if part["type"] == "text":
# string part => simply add the tokens
add_tokens(value_ids, 1)
elif part["type"] == "python":
# python tool call => add the tokens inside <|python_start|> and <|python_end|>
add_tokens(python_start, 1)
add_tokens(value_ids, 1)
add_tokens(python_end, 1)
elif part["type"] == "python_output":
# python output => add the tokens inside <|output_start|> and <|output_end|>
# none of these tokens are supervised because the tokens come from Python at test time
add_tokens(output_start, 0)
add_tokens(value_ids, 0)
add_tokens(output_end, 0)
else:
raise ValueError(f"Unknown part type: {part['type']}")
else:
raise ValueError(f"Unknown content type: {type(content)}")
add_tokens(assistant_end, 1)
# truncate to max_tokens tokens MAX (helps prevent OOMs)
ids = ids[:max_tokens]
mask = mask[:max_tokens]
return ids, mask
def visualize_tokenization(self, ids, mask, with_token_id=False):
RED = '\033[91m'
GREEN = '\033[92m'
RESET = '\033[0m'
GRAY = '\033[90m'
tokens = []
for i, (token_id, mask_val) in enumerate(zip(ids, mask)):
token_str = self.decode([token_id])
color = GREEN if mask_val == 1 else RED
tokens.append(f"{color}{token_str}{RESET}")
if with_token_id:
tokens.append(f"{GRAY}({token_id}){RESET}")
return '|'.join(tokens)
def render_for_completion(self, conversation):
# We have some surgery to do: we need to pop the last message (of the Assistant)
conversation = copy.deepcopy(conversation) # avoid mutating the original
messages = conversation["messages"]
assert messages[-1]["role"] == "assistant", "Last message must be from the Assistant"
messages.pop() # remove the last message (of the Assistant) inplace
# Now tokenize the conversation
ids, mask = self.render_conversation(conversation)
# Finally, to prime the Assistant for a completion, append the Assistant start token
assistant_start = self.encode_special("<|assistant_start|>")
ids.append(assistant_start)
return ids
# -----------------------------------------------------------------------------
# nanochat-specific convenience functions
def get_tokenizer():
from nanochat.common import get_base_dir
base_dir = get_base_dir()
tokenizer_dir = os.path.join(base_dir, "tokenizer")
# return HuggingFaceTokenizer.from_directory(tokenizer_dir)
return RustBPETokenizer.from_directory(tokenizer_dir)
def get_token_bytes(device="cpu"):
import torch
from nanochat.common import get_base_dir
base_dir = get_base_dir()
tokenizer_dir = os.path.join(base_dir, "tokenizer")
token_bytes_path = os.path.join(tokenizer_dir, "token_bytes.pt")
assert os.path.exists(token_bytes_path), f"Token bytes not found at {token_bytes_path}? It gets written by tok_train.py"
with open(token_bytes_path, "rb") as f:
token_bytes = torch.load(f, map_location=device)
return token_bytes | --- +++ @@ -1,3 +1,10 @@+"""
+BPE Tokenizer in the style of GPT-4.
+
+Two implementations are available:
+1) HuggingFace Tokenizer that can do both training and inference but is really confusing
+2) Our own RustBPE Tokenizer for training and tiktoken for efficient inference
+"""
import os
import copy
@@ -30,6 +37,7 @@ from tokenizers.trainers import BpeTrainer
class HuggingFaceTokenizer:
+ """Light wrapper around HuggingFace Tokenizer for some utilities"""
def __init__(self, tokenizer):
self.tokenizer = tokenizer
@@ -153,6 +161,7 @@ import tiktoken
class RustBPETokenizer:
+ """Light wrapper around tiktoken (for efficient inference) but train with rustbpe"""
def __init__(self, enc, bos_token):
self.enc = enc
@@ -255,6 +264,12 @@ print(f"Saved tokenizer encoding to {pickle_path}")
def render_conversation(self, conversation, max_tokens=2048):
+ """
+ Tokenize a single Chat conversation (which we call a "doc" or "document" here).
+ Returns:
+ - ids: list[int] is a list of token ids of this rendered conversation
+ - mask: list[int] of same length, mask = 1 for tokens that the Assistant is expected to train on.
+ """
# ids, masks that we will return and a helper function to help build them up.
ids, mask = [], []
def add_tokens(token_ids, mask_val):
@@ -335,6 +350,7 @@ return ids, mask
def visualize_tokenization(self, ids, mask, with_token_id=False):
+ """Small helper function useful in debugging: visualize the tokenization of render_conversation"""
RED = '\033[91m'
GREEN = '\033[92m'
RESET = '\033[0m'
@@ -349,6 +365,11 @@ return '|'.join(tokens)
def render_for_completion(self, conversation):
+ """
+ Used during Reinforcement Learning. In that setting, we want to
+ render the conversation priming the Assistant for a completion.
+ Unlike the Chat SFT case, we don't need to return the mask.
+ """
# We have some surgery to do: we need to pop the last message (of the Assistant)
conversation = copy.deepcopy(conversation) # avoid mutating the original
messages = conversation["messages"]
@@ -382,4 +403,4 @@ assert os.path.exists(token_bytes_path), f"Token bytes not found at {token_bytes_path}? It gets written by tok_train.py"
with open(token_bytes_path, "rb") as f:
token_bytes = torch.load(f, map_location=device)
- return token_bytes+ return token_bytes
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/tokenizer.py |
Add docstrings that explain purpose and usage |
import os
import re
import shutil
import subprocess
import socket
import datetime
import platform
import psutil
import torch
def run_command(cmd):
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=5)
# Return stdout if we got output (even if some files in xargs failed)
if result.stdout.strip():
return result.stdout.strip()
if result.returncode == 0:
return ""
return None
except:
return None
def get_git_info():
info = {}
info['commit'] = run_command("git rev-parse --short HEAD") or "unknown"
info['branch'] = run_command("git rev-parse --abbrev-ref HEAD") or "unknown"
# Check if repo is dirty (has uncommitted changes)
status = run_command("git status --porcelain")
info['dirty'] = bool(status) if status is not None else False
# Get commit message
info['message'] = run_command("git log -1 --pretty=%B") or ""
info['message'] = info['message'].split('\n')[0][:80] # First line, truncated
return info
def get_gpu_info():
if not torch.cuda.is_available():
return {"available": False}
num_devices = torch.cuda.device_count()
info = {
"available": True,
"count": num_devices,
"names": [],
"memory_gb": []
}
for i in range(num_devices):
props = torch.cuda.get_device_properties(i)
info["names"].append(props.name)
info["memory_gb"].append(props.total_memory / (1024**3))
# Get CUDA version
info["cuda_version"] = torch.version.cuda or "unknown"
return info
def get_system_info():
info = {}
# Basic system info
info['hostname'] = socket.gethostname()
info['platform'] = platform.system()
info['python_version'] = platform.python_version()
info['torch_version'] = torch.__version__
# CPU and memory
info['cpu_count'] = psutil.cpu_count(logical=False)
info['cpu_count_logical'] = psutil.cpu_count(logical=True)
info['memory_gb'] = psutil.virtual_memory().total / (1024**3)
# User and environment
info['user'] = os.environ.get('USER', 'unknown')
info['nanochat_base_dir'] = os.environ.get('NANOCHAT_BASE_DIR', 'out')
info['working_dir'] = os.getcwd()
return info
def estimate_cost(gpu_info, runtime_hours=None):
# Rough pricing, from Lambda Cloud
default_rate = 2.0
gpu_hourly_rates = {
"H100": 3.00,
"A100": 1.79,
"V100": 0.55,
}
if not gpu_info.get("available"):
return None
# Try to identify GPU type from name
hourly_rate = None
gpu_name = gpu_info["names"][0] if gpu_info["names"] else "unknown"
for gpu_type, rate in gpu_hourly_rates.items():
if gpu_type in gpu_name:
hourly_rate = rate * gpu_info["count"]
break
if hourly_rate is None:
hourly_rate = default_rate * gpu_info["count"] # Default estimate
return {
"hourly_rate": hourly_rate,
"gpu_type": gpu_name,
"estimated_total": hourly_rate * runtime_hours if runtime_hours else None
}
def generate_header():
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
git_info = get_git_info()
gpu_info = get_gpu_info()
sys_info = get_system_info()
cost_info = estimate_cost(gpu_info)
header = f"""# nanochat training report
Generated: {timestamp}
## Environment
### Git Information
- Branch: {git_info['branch']}
- Commit: {git_info['commit']} {"(dirty)" if git_info['dirty'] else "(clean)"}
- Message: {git_info['message']}
### Hardware
- Platform: {sys_info['platform']}
- CPUs: {sys_info['cpu_count']} cores ({sys_info['cpu_count_logical']} logical)
- Memory: {sys_info['memory_gb']:.1f} GB
"""
if gpu_info.get("available"):
gpu_names = ", ".join(set(gpu_info["names"]))
total_vram = sum(gpu_info["memory_gb"])
header += f"""- GPUs: {gpu_info['count']}x {gpu_names}
- GPU Memory: {total_vram:.1f} GB total
- CUDA Version: {gpu_info['cuda_version']}
"""
else:
header += "- GPUs: None available\n"
if cost_info and cost_info["hourly_rate"] > 0:
header += f"""- Hourly Rate: ${cost_info['hourly_rate']:.2f}/hour\n"""
header += f"""
### Software
- Python: {sys_info['python_version']}
- PyTorch: {sys_info['torch_version']}
"""
# bloat metrics: count lines/chars in git-tracked source files only
extensions = ['py', 'md', 'rs', 'html', 'toml', 'sh']
git_patterns = ' '.join(f"'*.{ext}'" for ext in extensions)
files_output = run_command(f"git ls-files -- {git_patterns}")
file_list = [f for f in (files_output or '').split('\n') if f]
num_files = len(file_list)
num_lines = 0
num_chars = 0
if num_files > 0:
wc_output = run_command(f"git ls-files -- {git_patterns} | xargs wc -lc 2>/dev/null")
if wc_output:
total_line = wc_output.strip().split('\n')[-1]
parts = total_line.split()
if len(parts) >= 2:
num_lines = int(parts[0])
num_chars = int(parts[1])
num_tokens = num_chars // 4 # assume approximately 4 chars per token
# count dependencies via uv.lock
uv_lock_lines = 0
if os.path.exists('uv.lock'):
with open('uv.lock', 'r', encoding='utf-8') as f:
uv_lock_lines = len(f.readlines())
header += f"""
### Bloat
- Characters: {num_chars:,}
- Lines: {num_lines:,}
- Files: {num_files:,}
- Tokens (approx): {num_tokens:,}
- Dependencies (uv.lock lines): {uv_lock_lines:,}
"""
return header
# -----------------------------------------------------------------------------
def slugify(text):
return text.lower().replace(" ", "-")
# the expected files and their order
EXPECTED_FILES = [
"tokenizer-training.md",
"tokenizer-evaluation.md",
"base-model-training.md",
"base-model-loss.md",
"base-model-evaluation.md",
"chat-sft.md",
"chat-evaluation-sft.md",
"chat-rl.md",
"chat-evaluation-rl.md",
]
# the metrics we're currently interested in
chat_metrics = ["ARC-Easy", "ARC-Challenge", "MMLU", "GSM8K", "HumanEval", "ChatCORE"]
def extract(section, keys):
if not isinstance(keys, list):
keys = [keys] # convenience
out = {}
for line in section.split("\n"):
for key in keys:
if key in line:
out[key] = line.split(":")[1].strip()
return out
def extract_timestamp(content, prefix):
for line in content.split('\n'):
if line.startswith(prefix):
time_str = line.split(":", 1)[1].strip()
try:
return datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")
except:
pass
return None
class Report:
def __init__(self, report_dir):
os.makedirs(report_dir, exist_ok=True)
self.report_dir = report_dir
def log(self, section, data):
slug = slugify(section)
file_name = f"{slug}.md"
file_path = os.path.join(self.report_dir, file_name)
with open(file_path, "w", encoding="utf-8") as f:
f.write(f"## {section}\n")
f.write(f"timestamp: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
for item in data:
if not item:
# skip falsy values like None or empty dict etc.
continue
if isinstance(item, str):
# directly write the string
f.write(item)
else:
# render a dict
for k, v in item.items():
if isinstance(v, float):
vstr = f"{v:.4f}"
elif isinstance(v, int) and v >= 10000:
vstr = f"{v:,.0f}"
else:
vstr = str(v)
f.write(f"- {k}: {vstr}\n")
f.write("\n")
return file_path
def generate(self):
report_dir = self.report_dir
report_file = os.path.join(report_dir, "report.md")
print(f"Generating report to {report_file}")
final_metrics = {} # the most important final metrics we'll add as table at the end
start_time = None
end_time = None
with open(report_file, "w", encoding="utf-8") as out_file:
# write the header first
header_file = os.path.join(report_dir, "header.md")
if os.path.exists(header_file):
with open(header_file, "r", encoding="utf-8") as f:
header_content = f.read()
out_file.write(header_content)
start_time = extract_timestamp(header_content, "Run started:")
# capture bloat data for summary later (the stuff after Bloat header and until \n\n)
bloat_data = re.search(r"### Bloat\n(.*?)\n\n", header_content, re.DOTALL)
bloat_data = bloat_data.group(1) if bloat_data else ""
else:
start_time = None # will cause us to not write the total wall clock time
bloat_data = "[bloat data missing]"
print(f"Warning: {header_file} does not exist. Did you forget to run `nanochat reset`?")
# process all the individual sections
for file_name in EXPECTED_FILES:
section_file = os.path.join(report_dir, file_name)
if not os.path.exists(section_file):
print(f"Warning: {section_file} does not exist, skipping")
continue
with open(section_file, "r", encoding="utf-8") as in_file:
section = in_file.read()
# Extract timestamp from this section (the last section's timestamp will "stick" as end_time)
if "rl" not in file_name:
# Skip RL sections for end_time calculation because RL is experimental
end_time = extract_timestamp(section, "timestamp:")
# extract the most important metrics from the sections
if file_name == "base-model-evaluation.md":
final_metrics["base"] = extract(section, "CORE")
if file_name == "chat-evaluation-sft.md":
final_metrics["sft"] = extract(section, chat_metrics)
if file_name == "chat-evaluation-rl.md":
final_metrics["rl"] = extract(section, "GSM8K") # RL only evals GSM8K
# append this section of the report
out_file.write(section)
out_file.write("\n")
# add the final metrics table
out_file.write("## Summary\n\n")
# Copy over the bloat metrics from the header
out_file.write(bloat_data)
out_file.write("\n\n")
# Collect all unique metric names
all_metrics = set()
for stage_metrics in final_metrics.values():
all_metrics.update(stage_metrics.keys())
# Custom ordering: CORE first, ChatCORE last, rest in middle
all_metrics = sorted(all_metrics, key=lambda x: (x != "CORE", x == "ChatCORE", x))
# Fixed column widths
stages = ["base", "sft", "rl"]
metric_width = 15
value_width = 8
# Write table header
header = f"| {'Metric'.ljust(metric_width)} |"
for stage in stages:
header += f" {stage.upper().ljust(value_width)} |"
out_file.write(header + "\n")
# Write separator
separator = f"|{'-' * (metric_width + 2)}|"
for stage in stages:
separator += f"{'-' * (value_width + 2)}|"
out_file.write(separator + "\n")
# Write table rows
for metric in all_metrics:
row = f"| {metric.ljust(metric_width)} |"
for stage in stages:
value = final_metrics.get(stage, {}).get(metric, "-")
row += f" {str(value).ljust(value_width)} |"
out_file.write(row + "\n")
out_file.write("\n")
# Calculate and write total wall clock time
if start_time and end_time:
duration = end_time - start_time
total_seconds = int(duration.total_seconds())
hours = total_seconds // 3600
minutes = (total_seconds % 3600) // 60
out_file.write(f"Total wall clock time: {hours}h{minutes}m\n")
else:
out_file.write("Total wall clock time: unknown\n")
# also cp the report.md file to current directory
print(f"Copying report.md to current directory for convenience")
shutil.copy(report_file, "report.md")
return report_file
def reset(self):
# Remove section files
for file_name in EXPECTED_FILES:
file_path = os.path.join(self.report_dir, file_name)
if os.path.exists(file_path):
os.remove(file_path)
# Remove report.md if it exists
report_file = os.path.join(self.report_dir, "report.md")
if os.path.exists(report_file):
os.remove(report_file)
# Generate and write the header section with start timestamp
header_file = os.path.join(self.report_dir, "header.md")
header = generate_header()
start_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with open(header_file, "w", encoding="utf-8") as f:
f.write(header)
f.write(f"Run started: {start_time}\n\n---\n\n")
print(f"Reset report and wrote header to {header_file}")
# -----------------------------------------------------------------------------
# nanochat-specific convenience functions
class DummyReport:
def log(self, *args, **kwargs):
pass
def reset(self, *args, **kwargs):
pass
def get_report():
# just for convenience, only rank 0 logs to report
from nanochat.common import get_base_dir, get_dist_info
ddp, ddp_rank, ddp_local_rank, ddp_world_size = get_dist_info()
if ddp_rank == 0:
report_dir = os.path.join(get_base_dir(), "report")
return Report(report_dir)
else:
return DummyReport()
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Generate or reset nanochat training reports.")
parser.add_argument("command", nargs="?", default="generate", choices=["generate", "reset"], help="Operation to perform (default: generate)")
args = parser.parse_args()
if args.command == "generate":
get_report().generate()
elif args.command == "reset":
get_report().reset() | --- +++ @@ -1,3 +1,6 @@+"""
+Utilities for generating training report cards. More messy code than usual, will fix.
+"""
import os
import re
@@ -10,6 +13,7 @@ import torch
def run_command(cmd):
+ """Run a shell command and return output, or None if it fails."""
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=5)
# Return stdout if we got output (even if some files in xargs failed)
@@ -22,6 +26,7 @@ return None
def get_git_info():
+ """Get current git commit, branch, and dirty status."""
info = {}
info['commit'] = run_command("git rev-parse --short HEAD") or "unknown"
info['branch'] = run_command("git rev-parse --abbrev-ref HEAD") or "unknown"
@@ -37,6 +42,7 @@ return info
def get_gpu_info():
+ """Get GPU information."""
if not torch.cuda.is_available():
return {"available": False}
@@ -59,6 +65,7 @@ return info
def get_system_info():
+ """Get system information."""
info = {}
# Basic system info
@@ -80,6 +87,7 @@ return info
def estimate_cost(gpu_info, runtime_hours=None):
+ """Estimate training cost based on GPU type and runtime."""
# Rough pricing, from Lambda Cloud
default_rate = 2.0
@@ -110,6 +118,7 @@ }
def generate_header():
+ """Generate the header for a training report."""
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
git_info = get_git_info()
@@ -192,6 +201,7 @@ # -----------------------------------------------------------------------------
def slugify(text):
+ """Slugify a text string."""
return text.lower().replace(" ", "-")
# the expected files and their order
@@ -210,6 +220,7 @@ chat_metrics = ["ARC-Easy", "ARC-Challenge", "MMLU", "GSM8K", "HumanEval", "ChatCORE"]
def extract(section, keys):
+ """simple def to extract a single key from a section"""
if not isinstance(keys, list):
keys = [keys] # convenience
out = {}
@@ -220,6 +231,7 @@ return out
def extract_timestamp(content, prefix):
+ """Extract timestamp from content with given prefix."""
for line in content.split('\n'):
if line.startswith(prefix):
time_str = line.split(":", 1)[1].strip()
@@ -230,12 +242,14 @@ return None
class Report:
+ """Maintains a bunch of logs, generates a final markdown report."""
def __init__(self, report_dir):
os.makedirs(report_dir, exist_ok=True)
self.report_dir = report_dir
def log(self, section, data):
+ """Log a section of data to the report."""
slug = slugify(section)
file_name = f"{slug}.md"
file_path = os.path.join(self.report_dir, file_name)
@@ -263,6 +277,7 @@ return file_path
def generate(self):
+ """Generate the final report."""
report_dir = self.report_dir
report_file = os.path.join(report_dir, "report.md")
print(f"Generating report to {report_file}")
@@ -354,6 +369,7 @@ return report_file
def reset(self):
+ """Reset the report."""
# Remove section files
for file_name in EXPECTED_FILES:
file_path = os.path.join(self.report_dir, file_name)
@@ -399,4 +415,4 @@ if args.command == "generate":
get_report().generate()
elif args.command == "reset":
- get_report().reset()+ get_report().reset()
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/nanochat/report.py |
Generate descriptive docstrings automatically | import os
import csv
import time
import json
import yaml
import shutil
import random
import zipfile
import tempfile
import argparse
import torch
from nanochat.common import compute_init, compute_cleanup, print0, get_base_dir, autodetect_device_type, download_file_with_lock
from nanochat.tokenizer import HuggingFaceTokenizer, get_token_bytes
from nanochat.checkpoint_manager import load_model
from nanochat.core_eval import evaluate_task
from nanochat.dataloader import tokenizing_distributed_data_loader_bos_bestfit
from nanochat.loss_eval import evaluate_bpb
from nanochat.engine import Engine
# -----------------------------------------------------------------------------
# HuggingFace loading utilities
class ModelWrapper:
def __init__(self, model, max_seq_len=None):
self.model = model
self.max_seq_len = max_seq_len
def __call__(self, input_ids, targets=None, loss_reduction='mean'):
logits = self.model(input_ids).logits
if targets is None:
return logits
loss = torch.nn.functional.cross_entropy(
logits.view(-1, logits.size(-1)),
targets.view(-1),
ignore_index=-1,
reduction=loss_reduction
)
return loss
def get_device(self):
return next(self.model.parameters()).device
def load_hf_model(hf_path: str, device):
print0(f"Loading HuggingFace model from: {hf_path}")
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(hf_path)
model.to(device)
model.eval()
max_seq_len = 1024 if "gpt2" in hf_path else None
model = ModelWrapper(model, max_seq_len=max_seq_len)
tokenizer = HuggingFaceTokenizer.from_pretrained(hf_path)
return model, tokenizer
def get_hf_token_bytes(tokenizer, device="cpu"):
vocab_size = tokenizer.tokenizer.get_vocab_size()
token_bytes = torch.zeros(vocab_size, dtype=torch.int64, device=device)
for token_id in range(vocab_size):
token_str = tokenizer.tokenizer.decode([token_id])
token_bytes[token_id] = len(token_str.encode('utf-8'))
return token_bytes
# -----------------------------------------------------------------------------
# CORE evaluation
EVAL_BUNDLE_URL = "https://karpathy-public.s3.us-west-2.amazonaws.com/eval_bundle.zip"
def place_eval_bundle(file_path):
base_dir = get_base_dir()
eval_bundle_dir = os.path.join(base_dir, "eval_bundle")
with tempfile.TemporaryDirectory() as tmpdir:
with zipfile.ZipFile(file_path, 'r') as zip_ref:
zip_ref.extractall(tmpdir)
extracted_bundle_dir = os.path.join(tmpdir, "eval_bundle")
shutil.move(extracted_bundle_dir, eval_bundle_dir)
print0(f"Placed eval_bundle directory at {eval_bundle_dir}")
def evaluate_core(model, tokenizer, device, max_per_task=-1):
base_dir = get_base_dir()
eval_bundle_dir = os.path.join(base_dir, "eval_bundle")
# Download the eval bundle if needed
if not os.path.exists(eval_bundle_dir):
download_file_with_lock(EVAL_BUNDLE_URL, "eval_bundle.zip", postprocess_fn=place_eval_bundle)
config_path = os.path.join(eval_bundle_dir, "core.yaml")
data_base_path = os.path.join(eval_bundle_dir, "eval_data")
eval_meta_data = os.path.join(eval_bundle_dir, "eval_meta_data.csv")
with open(config_path, 'r', encoding='utf-8') as f:
config = yaml.safe_load(f)
tasks = config['icl_tasks']
# Load random baseline values
random_baselines = {}
with open(eval_meta_data, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
task_name = row['Eval Task']
random_baseline = row['Random baseline']
random_baselines[task_name] = float(random_baseline)
# Evaluate each task
results = {}
centered_results = {}
for task in tasks:
start_time = time.time()
label = task['label']
task_meta = {
'task_type': task['icl_task_type'],
'dataset_uri': task['dataset_uri'],
'num_fewshot': task['num_fewshot'][0],
'continuation_delimiter': task.get('continuation_delimiter', ' ')
}
print0(f"Evaluating: {label} ({task_meta['num_fewshot']}-shot, type: {task_meta['task_type']})... ", end='')
data_path = os.path.join(data_base_path, task_meta['dataset_uri'])
with open(data_path, 'r', encoding='utf-8') as f:
data = [json.loads(line.strip()) for line in f]
# Shuffle for consistent subsampling when using max_per_task
shuffle_rng = random.Random(1337)
shuffle_rng.shuffle(data)
if max_per_task > 0:
data = data[:max_per_task]
accuracy = evaluate_task(model, tokenizer, data, device, task_meta)
results[label] = accuracy
random_baseline = random_baselines[label]
centered_result = (accuracy - 0.01 * random_baseline) / (1.0 - 0.01 * random_baseline)
centered_results[label] = centered_result
elapsed = time.time() - start_time
print0(f"accuracy: {accuracy:.4f} | centered: {centered_result:.4f} | time: {elapsed:.2f}s")
core_metric = sum(centered_results.values()) / len(centered_results)
out = {
"results": results,
"centered_results": centered_results,
"core_metric": core_metric
}
return out
# -----------------------------------------------------------------------------
# Main
def main():
parser = argparse.ArgumentParser(description="Base model evaluation")
parser.add_argument('--eval', type=str, default='core,bpb,sample', help='Comma-separated evaluations to run: core,bpb,sample (default: all)')
parser.add_argument('--hf-path', type=str, default=None, help='HuggingFace model path (e.g. openai-community/gpt2-xl)')
parser.add_argument('--model-tag', type=str, default=None, help='nanochat model tag to identify the checkpoint directory')
parser.add_argument('--step', type=int, default=None, help='Model step to load (default = last)')
parser.add_argument('--max-per-task', type=int, default=-1, help='Max examples per CORE task (-1 = all)')
parser.add_argument('--device-batch-size', type=int, default=32, help='Per-device batch size for BPB evaluation')
parser.add_argument('--split-tokens', type=int, default=40*524288, help='Number of tokens to evaluate per split for BPB')
parser.add_argument('--device-type', type=str, default='', help='cuda|cpu|mps (empty = autodetect)')
args = parser.parse_args()
# Parse evaluation modes
eval_modes = set(mode.strip() for mode in args.eval.split(','))
valid_modes = {'core', 'bpb', 'sample'}
invalid = eval_modes - valid_modes
if invalid:
parser.error(f"Invalid eval modes: {invalid}. Valid: {valid_modes}")
# Distributed / precision setup
device_type = autodetect_device_type() if args.device_type == '' else args.device_type
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
# Load model and tokenizer
is_hf_model = args.hf_path is not None
if is_hf_model:
model, tokenizer = load_hf_model(args.hf_path, device)
sequence_len = model.max_seq_len or 1024
token_bytes = get_hf_token_bytes(tokenizer, device=device)
model_name = args.hf_path
model_slug = args.hf_path.replace("/", "-")
else:
model, tokenizer, meta = load_model("base", device, phase="eval", model_tag=args.model_tag, step=args.step)
sequence_len = meta["model_config"]["sequence_len"]
token_bytes = get_token_bytes(device=device)
model_name = f"base_model (step {meta['step']})"
model_slug = f"base_model_{meta['step']:06d}"
print0(f"Evaluating model: {model_name}")
print0(f"Eval modes: {', '.join(sorted(eval_modes))}")
# Results to log
core_results = None
bpb_results = {}
samples = []
unconditioned_samples = []
# --- Sampling ---
if 'sample' in eval_modes and not is_hf_model:
print0("\n" + "="*80)
print0("Model Samples")
print0("="*80)
if ddp_rank == 0:
prompts = [
"The capital of France is",
"The chemical symbol of gold is",
"If yesterday was Friday, then tomorrow will be",
"The opposite of hot is",
"The planets of the solar system are:",
"My favorite color is",
"If 5*x + 3 = 13, then x is",
]
engine = Engine(model, tokenizer)
print0("\nConditioned samples:")
for prompt in prompts:
tokens = tokenizer(prompt, prepend="<|bos|>")
sample, _ = engine.generate_batch(tokens, num_samples=1, max_tokens=16, temperature=0)
sample_str = tokenizer.decode(sample[0])
print0("-" * 80)
print0(sample_str)
samples.append(sample_str)
print0("\nUnconditioned samples:")
tokens = tokenizer("", prepend="<|bos|>")
uncond, _ = engine.generate_batch(tokens, num_samples=8, max_tokens=128, temperature=1.0)
for sample in uncond:
sample_str = tokenizer.decode(sample)
print0("-" * 80)
print0(sample_str)
unconditioned_samples.append(sample_str)
elif 'sample' in eval_modes and is_hf_model:
print0("\nSkipping sampling for HuggingFace models (not supported)")
# --- BPB evaluation ---
if 'bpb' in eval_modes:
print0("\n" + "="*80)
print0("BPB Evaluation")
print0("="*80)
tokens_per_step = args.device_batch_size * sequence_len * ddp_world_size
if args.split_tokens % tokens_per_step != 0:
# Adjust to nearest multiple
args.split_tokens = (args.split_tokens // tokens_per_step) * tokens_per_step
print0(f"Adjusted split_tokens to {args.split_tokens} (must be divisible by {tokens_per_step})")
steps = args.split_tokens // tokens_per_step
for split_name in ["train", "val"]:
loader = tokenizing_distributed_data_loader_bos_bestfit(tokenizer, args.device_batch_size, sequence_len, split_name, device=device)
bpb = evaluate_bpb(model, loader, steps, token_bytes)
bpb_results[split_name] = bpb
print0(f"{split_name} bpb: {bpb:.6f}")
# --- CORE evaluation ---
if 'core' in eval_modes:
print0("\n" + "="*80)
print0("CORE Evaluation")
print0("="*80)
core_results = evaluate_core(model, tokenizer, device, max_per_task=args.max_per_task)
# Write CSV output
if ddp_rank == 0:
base_dir = get_base_dir()
output_csv_path = os.path.join(base_dir, "base_eval", f"{model_slug}.csv")
os.makedirs(os.path.dirname(output_csv_path), exist_ok=True)
with open(output_csv_path, 'w', encoding='utf-8', newline='') as f:
f.write(f"{'Task':<35}, {'Accuracy':<10}, {'Centered':<10}\n")
for label in core_results["results"]:
acc = core_results["results"][label]
centered = core_results["centered_results"][label]
f.write(f"{label:<35}, {acc:<10.6f}, {centered:<10.6f}\n")
f.write(f"{'CORE':<35}, {'':<10}, {core_results['core_metric']:<10.6f}\n")
print0(f"\nResults written to: {output_csv_path}")
print0(f"CORE metric: {core_results['core_metric']:.4f}")
# --- Log to report ---
from nanochat.report import get_report
report_data = [{"model": model_name}]
if core_results:
report_data[0]["CORE metric"] = core_results["core_metric"]
report_data.append(core_results["centered_results"])
if bpb_results:
report_data[0]["train bpb"] = bpb_results.get("train")
report_data[0]["val bpb"] = bpb_results.get("val")
if samples:
report_data.append({f"sample {i}": s for i, s in enumerate(samples)})
if unconditioned_samples:
report_data.append({f"unconditioned {i}": s for i, s in enumerate(unconditioned_samples)})
get_report().log(section="Base model evaluation", data=report_data)
compute_cleanup()
if __name__ == "__main__":
main() | --- +++ @@ -1,3 +1,24 @@+"""
+Unified evaluation script for base models.
+
+Supports three evaluation modes (comma-separated):
+ --eval core : CORE metric (accuracy on ICL tasks)
+ --eval bpb : Bits per byte on train/val splits
+ --eval sample : Generate samples from the model
+
+Default is all three: --eval core,bpb,sample
+
+Examples:
+
+ # Evaluate a HuggingFace model (e.g. GPT-2 124M) using 8 GPUs
+ torchrun --nproc_per_node=8 -m scripts.base_eval --hf-path openai-community/gpt2
+
+ # Evaluate a nanochat model (e.g. d24) using 8 GPUs
+ torchrun --nproc_per_node=8 -m scripts.base_eval --model-tag d24 --device-batch-size=16
+
+ # Quick/approximate evaluation using a single GPU
+ python -m scripts.base_eval --model-tag d24 --device-batch-size=16 --max-per-task=100 --split-tokens=524288
+"""
import os
import csv
import time
@@ -22,6 +43,7 @@ # HuggingFace loading utilities
class ModelWrapper:
+ """Lightweight wrapper to give HuggingFace models a nanochat-compatible interface."""
def __init__(self, model, max_seq_len=None):
self.model = model
self.max_seq_len = max_seq_len
@@ -43,6 +65,7 @@
def load_hf_model(hf_path: str, device):
+ """Load a HuggingFace model and tokenizer."""
print0(f"Loading HuggingFace model from: {hf_path}")
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(hf_path)
@@ -55,6 +78,7 @@
def get_hf_token_bytes(tokenizer, device="cpu"):
+ """Compute token_bytes tensor for a HuggingFace tokenizer."""
vocab_size = tokenizer.tokenizer.get_vocab_size()
token_bytes = torch.zeros(vocab_size, dtype=torch.int64, device=device)
for token_id in range(vocab_size):
@@ -69,6 +93,7 @@
def place_eval_bundle(file_path):
+ """Unzip eval_bundle.zip and place it in the base directory."""
base_dir = get_base_dir()
eval_bundle_dir = os.path.join(base_dir, "eval_bundle")
with tempfile.TemporaryDirectory() as tmpdir:
@@ -80,6 +105,10 @@
def evaluate_core(model, tokenizer, device, max_per_task=-1):
+ """
+ Evaluate a base model on the CORE benchmark.
+ Returns dict with results, centered_results, and core_metric.
+ """
base_dir = get_base_dir()
eval_bundle_dir = os.path.join(base_dir, "eval_bundle")
# Download the eval bundle if needed
@@ -291,4 +320,4 @@
if __name__ == "__main__":
- main()+ main()
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/base_eval.py |
Replace inline comments with docstrings |
import os
os.environ["PYTORCH_ALLOC_CONF"] = "expandable_segments:True"
import gc
import json
import time
import math
import argparse
from dataclasses import asdict
from contextlib import contextmanager
import wandb
import torch
import torch.distributed as dist
from nanochat.gpt import GPT, GPTConfig, Linear
from nanochat.dataloader import tokenizing_distributed_data_loader_bos_bestfit, tokenizing_distributed_data_loader_with_state_bos_bestfit
from nanochat.common import compute_init, compute_cleanup, print0, DummyWandb, print_banner, get_base_dir, autodetect_device_type, get_peak_flops, COMPUTE_DTYPE, COMPUTE_DTYPE_REASON, is_ddp_initialized
from nanochat.tokenizer import get_tokenizer, get_token_bytes
from nanochat.checkpoint_manager import save_checkpoint, load_checkpoint
from nanochat.loss_eval import evaluate_bpb
from nanochat.engine import Engine
from nanochat.flash_attention import HAS_FA3
from scripts.base_eval import evaluate_core
print_banner()
# -----------------------------------------------------------------------------
# CLI arguments
parser = argparse.ArgumentParser(description="Pretrain base model")
# Logging
parser.add_argument("--run", type=str, default="dummy", help="wandb run name ('dummy' disables wandb logging)")
# Runtime
parser.add_argument("--device-type", type=str, default="", help="cuda|cpu|mps (empty = autodetect)")
# FP8 training
parser.add_argument("--fp8", action="store_true", help="enable FP8 training (requires H100+ GPU and torchao)")
parser.add_argument("--fp8-recipe", type=str, default="tensorwise", choices=["rowwise", "tensorwise"], help="FP8 scaling recipe: tensorwise (faster, recommended) or rowwise (more accurate but slower)")
# Model architecture
parser.add_argument("--depth", type=int, default=20, help="depth of the Transformer model")
parser.add_argument("--aspect-ratio", type=int, default=64, help="model_dim = depth * aspect_ratio")
parser.add_argument("--head-dim", type=int, default=128, help="target head dimension for attention")
parser.add_argument("--max-seq-len", type=int, default=2048, help="max context length")
parser.add_argument("--window-pattern", type=str, default="SSSL", help="sliding window pattern tiled across layers: L=full, S=half context (e.g. 'SSL')")
# Training horizon (only one used, in order of precedence)
parser.add_argument("--num-iterations", type=int, default=-1, help="explicit number of optimization steps (-1 = disable)")
parser.add_argument("--target-flops", type=float, default=-1.0, help="calculate num_iterations to reach target_flops (-1 = disable)")
parser.add_argument("--target-param-data-ratio", type=float, default=10.5, help="calculate num_iterations to maintain data:param ratio (Chinchilla=20, -1 = disable)")
# Optimization
parser.add_argument("--device-batch-size", type=int, default=32, help="per-device batch size. good number to reduce to 16,8,4,... if you OOM on VRAM.")
parser.add_argument("--total-batch-size", type=int, default=-1, help="total batch size in tokens. decent numbers are e.g. 524288. (-1 = auto-compute optimal)")
parser.add_argument("--embedding-lr", type=float, default=0.3, help="learning rate for embedding parameters (Adam)")
parser.add_argument("--unembedding-lr", type=float, default=0.008, help="learning rate for unembedding parameters (Adam)")
parser.add_argument("--weight-decay", type=float, default=0.28, help="cautious weight decay for the Muon optimizer (for weights)")
parser.add_argument("--matrix-lr", type=float, default=0.02, help="learning rate for matrix parameters (Muon)")
parser.add_argument("--scalar-lr", type=float, default=0.5, help="learning rate for scalars (resid_lambdas, x0_lambdas)")
parser.add_argument("--warmup-steps", type=int, default=40, help="number of steps for LR warmup")
parser.add_argument("--warmdown-ratio", type=float, default=0.65, help="ratio of iterations for LR warmdown")
parser.add_argument("--final-lr-frac", type=float, default=0.05, help="final LR as fraction of initial LR")
parser.add_argument("--resume-from-step", type=int, default=-1, help="resume training from this step (-1 = disable)")
# Evaluation
parser.add_argument("--eval-every", type=int, default=250, help="evaluate val bpb every N steps (-1 = disable)")
parser.add_argument("--eval-tokens", type=int, default=80*524288, help="number of tokens to evaluate val loss on")
parser.add_argument("--core-metric-every", type=int, default=2000, help="evaluate CORE metric every N steps (-1 = disable)")
parser.add_argument("--core-metric-max-per-task", type=int, default=500, help="examples per task for CORE metric")
parser.add_argument("--sample-every", type=int, default=2000, help="sample from model every N steps (-1 = disable)")
parser.add_argument("--save-every", type=int, default=-1, help="save checkpoints every N steps (-1 = only at end)")
# Output
parser.add_argument("--model-tag", type=str, default=None, help="override model tag for checkpoint directory name")
args = parser.parse_args()
user_config = vars(args).copy() # for logging
# -----------------------------------------------------------------------------
# Compute init and wandb logging
device_type = autodetect_device_type() if args.device_type == "" else args.device_type
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
synchronize = torch.cuda.synchronize if device_type == "cuda" else lambda: None
get_max_memory = torch.cuda.max_memory_allocated if device_type == "cuda" else lambda: 0
if device_type == "cuda":
gpu_device_name = torch.cuda.get_device_name(0)
gpu_peak_flops = get_peak_flops(gpu_device_name)
print0(f"GPU: {gpu_device_name} | Peak FLOPS (BF16): {gpu_peak_flops:.2e}")
else:
gpu_peak_flops = float('inf') # MFU not meaningful for CPU/MPS
print0(f"COMPUTE_DTYPE: {COMPUTE_DTYPE} ({COMPUTE_DTYPE_REASON})")
# wandb logging init
use_dummy_wandb = args.run == "dummy" or not master_process
wandb_run = DummyWandb() if use_dummy_wandb else wandb.init(project="nanochat", name=args.run, config=user_config)
# Flash Attention status
from nanochat.flash_attention import USE_FA3
using_fa3 = USE_FA3
if using_fa3:
print0("✓ Using Flash Attention 3 (Hopper GPU detected), efficient, new and awesome.")
else:
print0("!" * 80)
if HAS_FA3 and COMPUTE_DTYPE != torch.bfloat16:
print0(f"WARNING: Flash Attention 3 only supports bf16, but COMPUTE_DTYPE={COMPUTE_DTYPE}. Using PyTorch SDPA fallback")
else:
print0("WARNING: Flash Attention 3 not available, using PyTorch SDPA fallback")
print0("WARNING: Training will be less efficient without FA3")
if args.window_pattern != "L":
print0(f"WARNING: SDPA has no support for sliding window attention (window_pattern='{args.window_pattern}'). Your GPU utilization will be terrible.")
print0("WARNING: Recommend using --window-pattern L for full context attention without alternating sliding window patterns.")
print0("!" * 80)
# -----------------------------------------------------------------------------
# Tokenizer will be useful for evaluation and also we need the vocab size to init the model
tokenizer = get_tokenizer()
token_bytes = get_token_bytes(device=device)
vocab_size = tokenizer.get_vocab_size()
print0(f"Vocab size: {vocab_size:,}")
# -----------------------------------------------------------------------------
# Initialize the Model
def build_model_meta(depth):
# Model dim is nudged up to nearest multiple of head_dim for clean division
# (FA3 requires head_dim divisible by 8, and this guarantees head_dim == args.head_dim exactly)
base_dim = depth * args.aspect_ratio
model_dim = ((base_dim + args.head_dim - 1) // args.head_dim) * args.head_dim
num_heads = model_dim // args.head_dim
config = GPTConfig(
sequence_len=args.max_seq_len, vocab_size=vocab_size,
n_layer=depth, n_head=num_heads, n_kv_head=num_heads, n_embd=model_dim,
window_pattern=args.window_pattern,
)
with torch.device("meta"):
model_meta = GPT(config)
return model_meta
# Build the model, move to device, init the weights
model = build_model_meta(args.depth) # 1) Build on meta device (only shapes/dtypes, no data)
model_config = model.config
model_config_kwargs = asdict(model_config)
print0(f"Model config:\n{json.dumps(model_config_kwargs, indent=2)}")
model.to_empty(device=device) # 2) All tensors get storage on target device but with uninitialized (garbage) data
model.init_weights() # 3) All tensors get initialized
# If we are resuming, overwrite the model parameters with those of the checkpoint
base_dir = get_base_dir()
output_dirname = args.model_tag if args.model_tag else f"d{args.depth}" # e.g. d12
checkpoint_dir = os.path.join(base_dir, "base_checkpoints", output_dirname)
resuming = args.resume_from_step != -1
if resuming:
print0(f"Resuming optimization from step {args.resume_from_step}")
model_data, optimizer_data, meta_data = load_checkpoint(checkpoint_dir, args.resume_from_step, device, load_optimizer=True, rank=ddp_rank)
model.load_state_dict(model_data, strict=True, assign=True)
del model_data # free up this memory after the copy
# -----------------------------------------------------------------------------
# FP8 training initialization and management (this has to be done before torch.compile)
# Convert Linear layers to Float8Linear if --fp8 is set
if args.fp8:
if device_type != "cuda":
print0("Warning: FP8 training requires CUDA, ignoring --fp8 flag")
else:
# our custom fp8 is simpler than torchao, written for exact API compatibility
from nanochat.fp8 import Float8LinearConfig, convert_to_float8_training
# from torchao.float8 import Float8LinearConfig, convert_to_float8_training
import torch.nn as nn
# Filter: dims must be divisible by 16 (FP8 hardware requirement) large enough
def fp8_module_filter(mod: nn.Module, fqn: str) -> bool:
if not isinstance(mod, nn.Linear):
return False
if mod.in_features % 16 != 0 or mod.out_features % 16 != 0:
return False
if min(mod.in_features, mod.out_features) < 128:
return False
return True
fp8_config = Float8LinearConfig.from_recipe_name(args.fp8_recipe)
num_linear = sum(1 for m in model.modules() if isinstance(m, nn.Linear))
convert_to_float8_training(model, config=fp8_config, module_filter_fn=fp8_module_filter)
num_fp8 = sum(1 for m in model.modules() if 'Float8' in type(m).__name__)
num_skipped = num_linear - num_fp8
print0(f"✓ FP8 training enabled ({args.fp8_recipe} scaling) - converted {num_fp8}/{num_linear} linear layers, skipped {num_skipped} (too small)")
# Context manager to temporarily disable FP8 so that model evaluation remains in BF16
@contextmanager
def disable_fp8(model):
import torch.nn as nn
# Find all Float8Linear modules and their locations
fp8_locations = [] # list of (parent_module, attr_name, fp8_module)
for name, module in model.named_modules():
if 'Float8' in type(module).__name__:
if '.' in name:
parent_name, attr_name = name.rsplit('.', 1)
parent = model.get_submodule(parent_name)
else:
parent = model
attr_name = name
fp8_locations.append((parent, attr_name, module))
if not fp8_locations:
yield # No FP8 modules, nothing to do
return
# Swap Float8Linear -> Linear (our custom class that casts weights to match input dtype)
for parent, attr_name, fp8_module in fp8_locations:
linear = Linear(
fp8_module.in_features,
fp8_module.out_features,
bias=fp8_module.bias is not None,
device=fp8_module.weight.device,
dtype=fp8_module.weight.dtype,
)
linear.weight = fp8_module.weight # share, don't copy
if fp8_module.bias is not None:
linear.bias = fp8_module.bias
setattr(parent, attr_name, linear)
try:
yield
finally:
# Restore Float8Linear modules
for parent, attr_name, fp8_module in fp8_locations:
setattr(parent, attr_name, fp8_module)
# -----------------------------------------------------------------------------
# Compile the model
orig_model = model # original, uncompiled model, for saving raw model state_dict and for inference/evaluation (because the shapes may change shape)
model = torch.compile(model, dynamic=False) # the inputs to model will never change shape so dynamic=False is safe
# -----------------------------------------------------------------------------
# Scaling laws and muP extrapolations to determine the optimal training horizon, batch size, learning rates, weight decay.
# Get the parameter counts of our model
param_counts = model.num_scaling_params()
print0(f"Parameter counts:")
for key, value in param_counts.items():
print0(f"{key:24s}: {value:,}")
num_params = param_counts['total']
num_flops_per_token = model.estimate_flops()
print0(f"Estimated FLOPs per token: {num_flops_per_token:e}")
# 1) Use scaling laws to determine the optimal training horizon in tokens
# The compute-optimal models satisfy the Tokens:Params ratio of --target-param-data-ratio (derived experimentally via scaling laws analysis).
# We've already initialized the model so we have Params. Optimal Tokens is now simply target-param-data-ratio * Params
def get_scaling_params(m):
# As for which params to use exactly, transformer matrices + lm_head gives cleanest scaling laws (see dev/LOG.md Jan 27, 2026)
params_counts = m.num_scaling_params()
scaling_params = params_counts['transformer_matrices'] + params_counts['lm_head']
return scaling_params
num_scaling_params = get_scaling_params(model)
target_tokens = int(args.target_param_data_ratio * num_scaling_params) # optimal tokens for the model we are about to train
# Our reference model is d12, this is where a lot of hyperparameters are tuned and then transfered to higher depths (muP style)
d12_ref = build_model_meta(12) # creates the model on meta device
D_REF = args.target_param_data_ratio * get_scaling_params(d12_ref) # compute-optimal d12 training horizon in tokens (measured empirically)
B_REF = 2**19 # optimal batch size at d12 ~= 524,288 tokens (measured empirically)
# 2) Now that we have the token horizon, we can calculate the optimal batch size
# We follow the Power Lines paper (Bopt ∝ D^0.383), ref: https://arxiv.org/abs/2505.13738
# The optimal batch size grows as approximately D^0.383, so e.g. if D doubles from d12 to d24, B should grow by 2^0.383 ≈ 1.3x.
total_batch_size = args.total_batch_size # user-provided override is possible
if total_batch_size == -1:
batch_size_ratio = target_tokens / D_REF
predicted_batch_size = B_REF * batch_size_ratio ** 0.383
total_batch_size = 2 ** round(math.log2(predicted_batch_size)) # clamp to nearest power of 2 for efficiency
print0(f"Auto-computed optimal batch size: {total_batch_size:,} tokens")
# 3) Knowing the batch size, we can now calculate a learning rate correction (bigger batch size allows higher learning rates)
batch_lr_scale = 1.0
batch_ratio = total_batch_size / B_REF # B/B_ref
if batch_ratio != 1.0:
# SGD: linear scaling with batch size is standard (not used in nanochat)
# AdamW: sqrt scaling is standard: η ∝ √(B/B_ref)
# Muon: we will use the same scaling for Muon as for AdamW: η ∝ √(B/B_ref) (not studied carefully, assumption!)
batch_lr_scale = batch_ratio ** 0.5 # η ∝ √(B/B_ref)
print0(f"Scaling LRs by {batch_lr_scale:.4f} for batch size {total_batch_size:,} (reference: {B_REF:,})")
# 4) Knowing the batch size and the token horizon, we can now calculate the appropriate weight decay scaling
# We adopt the T_epoch framework from https://arxiv.org/abs/2405.13698
# Central idea of the paper is that T_epoch = B/(η·λ·D) should remain constant.
# Above, we used learning rate scaling η ∝ √(B/B_ref). So it's a matter of ~10 lines of math to derive that to keep T_epoch constant, we need:
# λ = λ_ref · √(B/B_ref) · (D_ref/D)
# Note that these papers study AdamW, *not* Muon. We are blindly following AdamW theory for scaling hoping it ~works for Muon too.
weight_decay_scaled = args.weight_decay * math.sqrt(total_batch_size / B_REF) * (D_REF / target_tokens)
if weight_decay_scaled != args.weight_decay:
print0(f"Scaling weight decay from {args.weight_decay:.6f} to {weight_decay_scaled:.6f} for depth {args.depth}")
# -----------------------------------------------------------------------------
# Initialize the Optimizer (combined MuonAdamW: Muon for matrix params, AdamW for rest)
optimizer = model.setup_optimizer(
# AdamW hyperparameters
unembedding_lr=args.unembedding_lr * batch_lr_scale,
embedding_lr=args.embedding_lr * batch_lr_scale,
scalar_lr=args.scalar_lr * batch_lr_scale,
# Muon hyperparameters
matrix_lr=args.matrix_lr * batch_lr_scale,
weight_decay=weight_decay_scaled,
)
if resuming:
optimizer.load_state_dict(optimizer_data)
del optimizer_data
# -----------------------------------------------------------------------------
# GradScaler for fp16 training (bf16/fp32 don't need it — bf16 has the same exponent range as fp32)
scaler = torch.amp.GradScaler() if COMPUTE_DTYPE == torch.float16 else None
if scaler is not None:
print0("GradScaler enabled for fp16 training")
# -----------------------------------------------------------------------------
# Initialize the DataLoaders for train/val
dataloader_resume_state_dict = None if not resuming else meta_data["dataloader_state_dict"]
train_loader = tokenizing_distributed_data_loader_with_state_bos_bestfit(tokenizer, args.device_batch_size, args.max_seq_len, split="train", device=device, resume_state_dict=dataloader_resume_state_dict)
build_val_loader = lambda: tokenizing_distributed_data_loader_bos_bestfit(tokenizer, args.device_batch_size, args.max_seq_len, split="val", device=device)
x, y, dataloader_state_dict = next(train_loader) # kick off load of the very first batch of data
# -----------------------------------------------------------------------------
# Calculate the number of iterations we will train for and set up the various schedulers
# num_iterations: either it is given, or from target flops, or from target data:param ratio (in that order)
assert args.num_iterations > 0 or args.target_param_data_ratio > 0 or args.target_flops > 0
if args.num_iterations > 0:
# Override num_iterations to a specific value if given
num_iterations = args.num_iterations
print0(f"Using user-provided number of iterations: {num_iterations:,}")
elif args.target_flops > 0:
# Calculate the number of iterations from the target flops (used in scaling laws analysis, e.g. runs/scaling_laws.sh)
num_iterations = round(args.target_flops / (num_flops_per_token * total_batch_size))
print0(f"Calculated number of iterations from target FLOPs: {num_iterations:,}")
elif args.target_param_data_ratio > 0:
# Calculate the number of iterations from the target param data ratio (the most common use case)
num_iterations = target_tokens // total_batch_size
print0(f"Calculated number of iterations from target data:param ratio: {num_iterations:,}")
else:
raise ValueError("No training horizon specified")
total_tokens = total_batch_size * num_iterations # the actual number of tokens we will train for
print0(f"Total number of training tokens: {total_tokens:,}")
print0(f"Tokens : Scaling params ratio: {total_batch_size * num_iterations / num_scaling_params:.2f}") # e.g. Chinchilla was ~20
print0(f"Total training FLOPs estimate: {num_flops_per_token * total_tokens:e}")
# Learning rate schedule (linear warmup, constant, linear warmdown)
def get_lr_multiplier(it):
warmup_iters = args.warmup_steps
warmdown_iters = round(args.warmdown_ratio * num_iterations)
if it < warmup_iters:
return (it + 1) / warmup_iters
elif it <= num_iterations - warmdown_iters:
return 1.0
else:
progress = (num_iterations - it) / warmdown_iters
return progress * 1.0 + (1 - progress) * args.final_lr_frac
# Momentum scheduler for Muon optimizer (warms up to 0.97, warms down to 0.90 during LR warmdown)
def get_muon_momentum(it):
warmdown_iters = round(args.warmdown_ratio * num_iterations)
warmdown_start = num_iterations - warmdown_iters
if it < 400:
frac = it / 400
return (1 - frac) * 0.85 + frac * 0.97
elif it >= warmdown_start:
progress = (it - warmdown_start) / warmdown_iters
return 0.97 * (1 - progress) + 0.90 * progress
else:
return 0.97
# Weight decay scheduler for Muon optimizer (cosine decay to zero over the course of training)
def get_weight_decay(it):
return weight_decay_scaled * 0.5 * (1 + math.cos(math.pi * it / num_iterations))
# -----------------------------------------------------------------------------
# Training loop
# Loop state (variables updated by the training loop)
if not resuming:
step = 0
val_bpb = None # will be set if eval_every > 0
min_val_bpb = float("inf")
smooth_train_loss = 0 # EMA of training loss
total_training_time = 0 # total wall-clock time of training
else:
step = meta_data["step"]
loop_state = meta_data["loop_state"]
val_bpb = meta_data["val_bpb"]
min_val_bpb = loop_state["min_val_bpb"]
smooth_train_loss = loop_state["smooth_train_loss"]
total_training_time = loop_state["total_training_time"]
# Figure out the needed gradient accumulation micro-steps to reach the desired total batch size per step
tokens_per_fwdbwd = args.device_batch_size * args.max_seq_len # tokens per iteration for a single rank
world_tokens_per_fwdbwd = tokens_per_fwdbwd * ddp_world_size # total tokens per iteration for all ranks
assert total_batch_size % world_tokens_per_fwdbwd == 0
grad_accum_steps = total_batch_size // world_tokens_per_fwdbwd
print0(f"Tokens / micro-batch / rank: {args.device_batch_size} x {args.max_seq_len} = {tokens_per_fwdbwd:,}")
print0(f"Tokens / micro-batch: {world_tokens_per_fwdbwd:,}")
print0(f"Total batch size {total_batch_size:,} => gradient accumulation steps: {grad_accum_steps}")
# Go!
while True:
last_step = step == num_iterations # loop runs num_iterations+1 times so that we can eval/save at the end
flops_so_far = num_flops_per_token * total_batch_size * step
# once in a while: evaluate the val bpb (all ranks participate)
if args.eval_every > 0 and (last_step or step % args.eval_every == 0):
model.eval()
val_loader = build_val_loader()
eval_steps = args.eval_tokens // (args.device_batch_size * args.max_seq_len * ddp_world_size)
with disable_fp8(model):
val_bpb = evaluate_bpb(model, val_loader, eval_steps, token_bytes)
print0(f"Step {step:05d} | Validation bpb: {val_bpb:.6f}")
if val_bpb < min_val_bpb:
min_val_bpb = val_bpb
wandb_run.log({
"step": step,
"total_training_flops": flops_so_far,
"total_training_time": total_training_time,
"val/bpb": val_bpb,
})
model.train()
# once in a while: estimate the CORE metric (all ranks participate)
# use the original uncompiled model because the inputs keep changing shape
# disable FP8 for evaluation to use BF16 for more consistent/accurate results
results = {}
if args.core_metric_every > 0 and (last_step or (step > 0 and step % args.core_metric_every == 0)):
model.eval()
with disable_fp8(orig_model):
results = evaluate_core(orig_model, tokenizer, device, max_per_task=args.core_metric_max_per_task)
print0(f"Step {step:05d} | CORE metric: {results['core_metric']:.4f}")
wandb_run.log({
"step": step,
"total_training_flops": flops_so_far,
"core_metric": results["core_metric"],
"centered_results": results["centered_results"],
})
model.train()
# once in a while: sample from the model (only on master process)
# use the original uncompiled model because the inputs keep changing shape
if args.sample_every > 0 and master_process and (last_step or (step > 0 and step % args.sample_every == 0)):
model.eval()
prompts = [
"The capital of France is",
"The chemical symbol of gold is",
"If yesterday was Friday, then tomorrow will be",
"The opposite of hot is",
"The planets of the solar system are:",
"My favorite color is",
"If 5*x + 3 = 13, then x is",
]
engine = Engine(orig_model, tokenizer) # use orig_model to avoid recompilation
for prompt in prompts:
tokens = tokenizer(prompt, prepend="<|bos|>")
with disable_fp8(orig_model):
sample, _ = engine.generate_batch(tokens, num_samples=1, max_tokens=16, temperature=0)
print0(tokenizer.decode(sample[0]))
model.train()
# save checkpoint: at the end of the run, or every save_every steps, except at the first step or the resume step
if last_step or (step > 0 and step != args.resume_from_step and args.save_every > 0 and step % args.save_every == 0):
save_checkpoint(
checkpoint_dir,
step,
orig_model.state_dict(), # model parameters
optimizer.state_dict(), # optimizer state
{ # metadata saved as json
"step": step,
"val_bpb": val_bpb, # loss at last step
"model_config": model_config_kwargs,
"user_config": user_config, # inputs to the training script
"device_batch_size": args.device_batch_size,
"max_seq_len": args.max_seq_len,
"total_batch_size": total_batch_size,
"dataloader_state_dict": dataloader_state_dict,
"loop_state": { # all loop state (other than step) so that we can resume training
"min_val_bpb": min_val_bpb,
"smooth_train_loss": smooth_train_loss,
"total_training_time": total_training_time,
},
},
rank=ddp_rank,
)
# termination conditions (TODO: possibly also add loss explosions etc.)
if last_step:
break
# -------------------------------------------------------------------------
# single training step
# evaluate the gradient
synchronize()
t0 = time.time()
for micro_step in range(grad_accum_steps):
loss = model(x, y)
train_loss = loss.detach() # for logging
loss = loss / grad_accum_steps # each .backward() is a grad sum => normalize loss here
if scaler is not None:
scaler.scale(loss).backward()
else:
loss.backward()
x, y, dataloader_state_dict = next(train_loader) # prefetch the next batch while the GPU is busy with forward/backward
# step the optimizer
lrm = get_lr_multiplier(step)
muon_momentum = get_muon_momentum(step)
muon_weight_decay = get_weight_decay(step)
for group in optimizer.param_groups:
group["lr"] = group["initial_lr"] * lrm
if group['kind'] == 'muon':
group["momentum"] = muon_momentum
group["weight_decay"] = muon_weight_decay
if scaler is not None:
scaler.unscale_(optimizer)
# In distributed training, all ranks must agree on whether to skip the step.
# Each rank may independently encounter inf/nan gradients, so we all-reduce
# the found_inf flag (MAX = if any rank found inf, all ranks skip).
if is_ddp_initialized():
for v in scaler._found_inf_per_device(optimizer).values():
dist.all_reduce(v, op=dist.ReduceOp.MAX)
scaler.step(optimizer)
scaler.update()
else:
optimizer.step()
model.zero_grad(set_to_none=True)
train_loss_f = train_loss.item() # .item() is a CPU-GPU sync point
synchronize()
t1 = time.time()
dt = t1 - t0
# -------------------------------------------------------------------------
# logging (CPU action only)
ema_beta = 0.9 # EMA decay factor for some smoothing just for nicer logging
smooth_train_loss = ema_beta * smooth_train_loss + (1 - ema_beta) * train_loss_f # EMA the training loss
debiased_smooth_loss = smooth_train_loss / (1 - ema_beta**(step + 1)) # debias the EMA
pct_done = 100 * step / num_iterations
tok_per_sec = int(total_batch_size / dt)
flops_per_sec = num_flops_per_token * total_batch_size / dt
mfu = 100 * flops_per_sec / (gpu_peak_flops * ddp_world_size)
if step > 10:
total_training_time += dt # only count the time after the first 10 steps
# Calculate ETA based on average time per step (excluding first 10 steps)
steps_done = step - 10
if steps_done > 0:
avg_time_per_step = total_training_time / steps_done
remaining_steps = num_iterations - step
eta_seconds = remaining_steps * avg_time_per_step
eta_str = f" | eta: {eta_seconds/60:.1f}m"
else:
eta_str = ""
epoch = f"{dataloader_state_dict['epoch']} pq: {dataloader_state_dict['pq_idx']} rg: {dataloader_state_dict['rg_idx']}"
print0(f"step {step:05d}/{num_iterations:05d} ({pct_done:.2f}%) | loss: {debiased_smooth_loss:.6f} | lrm: {lrm:.2f} | dt: {dt * 1000:.2f}ms | tok/sec: {tok_per_sec:,} | bf16_mfu: {mfu:.2f} | epoch: {epoch} | total time: {total_training_time/60:.2f}m{eta_str}")
if step % 100 == 0:
log_data = {
"step": step,
"total_training_flops": flops_so_far,
"total_training_time": total_training_time,
"train/loss": debiased_smooth_loss,
"train/lrm": lrm,
"train/dt": dt,
"train/tok_per_sec": tok_per_sec,
"train/mfu": mfu,
"train/epoch": epoch,
}
wandb_run.log(log_data)
# state update
first_step_of_run = (step == 0) or (resuming and step == args.resume_from_step)
step += 1
# The garbage collector is sadly a little bit overactive and for some poorly understood reason,
# it spends ~500ms scanning for cycles quite frequently, just to end up cleaning up very few tiny objects each time.
# So we manually manage and help it out here
if first_step_of_run:
gc.collect() # manually collect a lot of garbage from setup
gc.freeze() # immediately freeze all currently surviving objects and exclude them from GC
gc.disable() # nuclear intervention here: disable GC entirely except:
elif step % 5000 == 0: # every 5000 steps...
gc.collect() # manually collect, just to be safe for very, very long runs
# print a few more stats
print0(f"Peak memory usage: {get_max_memory() / 1024 / 1024:.2f}MiB")
print0(f"Total training time: {total_training_time/60:.2f}m")
if val_bpb is not None:
print0(f"Minimum validation bpb: {min_val_bpb:.6f}")
# Log to report
from nanochat.report import get_report
get_report().log(section="Base model training", data=[
user_config, # CLI args
{ # stats about the training setup
"Number of parameters": num_params,
"Number of FLOPs per token": f"{num_flops_per_token:e}",
"Calculated number of iterations": num_iterations,
"Number of training tokens": total_tokens,
"Tokens : Scaling params ratio": total_batch_size * num_iterations / num_scaling_params,
"DDP world size": ddp_world_size,
"warmup_steps": args.warmup_steps,
"warmdown_ratio": args.warmdown_ratio,
"final_lr_frac": args.final_lr_frac,
},
{ # stats about training outcomes
"Minimum validation bpb": min_val_bpb if val_bpb is not None else None,
"Final validation bpb": val_bpb,
"CORE metric estimate": results.get("core_metric", None),
"MFU %": f"{mfu:.2f}%",
"Total training flops": f"{flops_so_far:e}",
"Total training time": f"{total_training_time/60:.2f}m",
"Peak memory usage": f"{get_max_memory() / 1024 / 1024:.2f}MiB",
}
])
# cleanup
wandb_run.finish() # wandb run finish
compute_cleanup() | --- +++ @@ -1,3 +1,15 @@+"""
+Train model. From root directory of the project, run as:
+
+python -m scripts.base_train
+
+or distributed as:
+
+torchrun --nproc_per_node=8 -m scripts.base_train
+
+If you are only on CPU/Macbook, you'll want to train a much much smaller LLM. Example:
+python -m scripts.base_train --depth=4 --max-seq-len=512 --device-batch-size=1 --eval-tokens=512 --core-metric-every=-1 --total-batch-size=512 --num-iterations=20
+"""
import os
os.environ["PYTORCH_ALLOC_CONF"] = "expandable_segments:True"
@@ -115,6 +127,7 @@ # Initialize the Model
def build_model_meta(depth):
+ """Build a model on meta device for a given depth (shapes/dtypes only, no data)."""
# Model dim is nudged up to nearest multiple of head_dim for clean division
# (FA3 requires head_dim divisible by 8, and this guarantees head_dim == args.head_dim exactly)
base_dim = depth * args.aspect_ratio
@@ -181,6 +194,11 @@ # Context manager to temporarily disable FP8 so that model evaluation remains in BF16
@contextmanager
def disable_fp8(model):
+ """Temporarily swap Float8Linear modules with nn.Linear for BF16 evaluation.
+
+ CastConfig is a frozen dataclass, so we can't mutate scaling_type. Instead,
+ we swap out Float8Linear modules entirely and restore them after.
+ """
import torch.nn as nn
# Find all Float8Linear modules and their locations
@@ -608,4 +626,4 @@
# cleanup
wandb_run.finish() # wandb run finish
-compute_cleanup()+compute_cleanup()
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/base_train.py |
Write Python docstrings for this snippet | #!/usr/bin/env python3
import argparse
import json
import os
import torch
import asyncio
import logging
import random
from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse, HTMLResponse, FileResponse
from pydantic import BaseModel
from typing import List, Optional, AsyncGenerator
from dataclasses import dataclass
from nanochat.common import compute_init, autodetect_device_type
from nanochat.checkpoint_manager import load_model
from nanochat.engine import Engine
# Abuse prevention limits
MAX_MESSAGES_PER_REQUEST = 500
MAX_MESSAGE_LENGTH = 8000
MAX_TOTAL_CONVERSATION_LENGTH = 32000
MIN_TEMPERATURE = 0.0
MAX_TEMPERATURE = 2.0
MIN_TOP_K = 0 # 0 disables top-k filtering, using full vocabulary
MAX_TOP_K = 200
MIN_MAX_TOKENS = 1
MAX_MAX_TOKENS = 4096
parser = argparse.ArgumentParser(description='NanoChat Web Server')
parser.add_argument('-n', '--num-gpus', type=int, default=1, help='Number of GPUs to use (default: 1)')
parser.add_argument('-i', '--source', type=str, default="sft", help="Source of the model: sft|rl")
parser.add_argument('-t', '--temperature', type=float, default=0.8, help='Default temperature for generation')
parser.add_argument('-k', '--top-k', type=int, default=50, help='Default top-k sampling parameter')
parser.add_argument('-m', '--max-tokens', type=int, default=512, help='Default max tokens for generation')
parser.add_argument('-g', '--model-tag', type=str, default=None, help='Model tag to load')
parser.add_argument('-s', '--step', type=int, default=None, help='Step to load')
parser.add_argument('-p', '--port', type=int, default=8000, help='Port to run the server on')
parser.add_argument('--device-type', type=str, default='', choices=['cuda', 'cpu', 'mps'], help='Device type for evaluation: cuda|cpu|mps. empty => autodetect')
parser.add_argument('--host', type=str, default='0.0.0.0', help='Host to bind the server to')
args = parser.parse_args()
# Configure logging for conversation traffic
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)
device_type = autodetect_device_type() if args.device_type == "" else args.device_type
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
@dataclass
class Worker:
gpu_id: int
device: torch.device
engine: Engine
tokenizer: object
class WorkerPool:
def __init__(self, num_gpus: Optional[int] = None):
if num_gpus is None:
if device_type == "cuda":
num_gpus = torch.cuda.device_count()
else:
num_gpus = 1 # e.g. cpu|mps
self.num_gpus = num_gpus
self.workers: List[Worker] = []
self.available_workers: asyncio.Queue = asyncio.Queue()
async def initialize(self, source: str, model_tag: Optional[str] = None, step: Optional[int] = None):
print(f"Initializing worker pool with {self.num_gpus} GPUs...")
if self.num_gpus > 1:
assert device_type == "cuda", "Only CUDA supports multiple workers/GPUs. cpu|mps does not."
for gpu_id in range(self.num_gpus):
if device_type == "cuda":
device = torch.device(f"cuda:{gpu_id}")
print(f"Loading model on GPU {gpu_id}...")
else:
device = torch.device(device_type) # e.g. cpu|mps
print(f"Loading model on {device_type}...")
model, tokenizer, _ = load_model(source, device, phase="eval", model_tag=model_tag, step=step)
engine = Engine(model, tokenizer)
worker = Worker(
gpu_id=gpu_id,
device=device,
engine=engine,
tokenizer=tokenizer,
)
self.workers.append(worker)
await self.available_workers.put(worker)
print(f"All {self.num_gpus} workers initialized!")
async def acquire_worker(self) -> Worker:
return await self.available_workers.get()
async def release_worker(self, worker: Worker):
await self.available_workers.put(worker)
class ChatMessage(BaseModel):
role: str
content: str
class ChatRequest(BaseModel):
messages: List[ChatMessage]
temperature: Optional[float] = None
max_tokens: Optional[int] = None
top_k: Optional[int] = None
def validate_chat_request(request: ChatRequest):
# Check number of messages
if len(request.messages) == 0:
raise HTTPException(status_code=400, detail="At least one message is required")
if len(request.messages) > MAX_MESSAGES_PER_REQUEST:
raise HTTPException(
status_code=400,
detail=f"Too many messages. Maximum {MAX_MESSAGES_PER_REQUEST} messages allowed per request"
)
# Check individual message lengths and total conversation length
total_length = 0
for i, message in enumerate(request.messages):
if not message.content:
raise HTTPException(status_code=400, detail=f"Message {i} has empty content")
msg_length = len(message.content)
if msg_length > MAX_MESSAGE_LENGTH:
raise HTTPException(
status_code=400,
detail=f"Message {i} is too long. Maximum {MAX_MESSAGE_LENGTH} characters allowed per message"
)
total_length += msg_length
if total_length > MAX_TOTAL_CONVERSATION_LENGTH:
raise HTTPException(
status_code=400,
detail=f"Total conversation is too long. Maximum {MAX_TOTAL_CONVERSATION_LENGTH} characters allowed"
)
# Validate role values
for i, message in enumerate(request.messages):
if message.role not in ["user", "assistant"]:
raise HTTPException(
status_code=400,
detail=f"Message {i} has invalid role. Must be 'user', 'assistant', or 'system'"
)
# Validate temperature
if request.temperature is not None:
if not (MIN_TEMPERATURE <= request.temperature <= MAX_TEMPERATURE):
raise HTTPException(
status_code=400,
detail=f"Temperature must be between {MIN_TEMPERATURE} and {MAX_TEMPERATURE}"
)
# Validate top_k
if request.top_k is not None:
if not (MIN_TOP_K <= request.top_k <= MAX_TOP_K):
raise HTTPException(
status_code=400,
detail=f"top_k must be between {MIN_TOP_K} and {MAX_TOP_K}"
)
# Validate max_tokens
if request.max_tokens is not None:
if not (MIN_MAX_TOKENS <= request.max_tokens <= MAX_MAX_TOKENS):
raise HTTPException(
status_code=400,
detail=f"max_tokens must be between {MIN_MAX_TOKENS} and {MAX_MAX_TOKENS}"
)
@asynccontextmanager
async def lifespan(app: FastAPI):
print("Loading nanochat models across GPUs...")
app.state.worker_pool = WorkerPool(num_gpus=args.num_gpus)
await app.state.worker_pool.initialize(args.source, model_tag=args.model_tag, step=args.step)
print(f"Server ready at http://localhost:{args.port}")
yield
app = FastAPI(lifespan=lifespan)
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
@app.get("/")
async def root():
ui_html_path = os.path.join("nanochat", "ui.html")
with open(ui_html_path, "r", encoding="utf-8") as f:
html_content = f.read()
# Replace the API_URL to use the same origin
html_content = html_content.replace(
"const API_URL = `http://${window.location.hostname}:8000`;",
"const API_URL = '';"
)
return HTMLResponse(content=html_content)
@app.get("/logo.svg")
async def logo():
logo_path = os.path.join("nanochat", "logo.svg")
return FileResponse(logo_path, media_type="image/svg+xml")
async def generate_stream(
worker: Worker,
tokens,
temperature=None,
max_new_tokens=None,
top_k=None
) -> AsyncGenerator[str, None]:
temperature = temperature if temperature is not None else args.temperature
max_new_tokens = max_new_tokens if max_new_tokens is not None else args.max_tokens
top_k = top_k if top_k is not None else args.top_k
assistant_end = worker.tokenizer.encode_special("<|assistant_end|>")
bos = worker.tokenizer.get_bos_token_id()
# Accumulate tokens to properly handle multi-byte UTF-8 characters (like emojis)
accumulated_tokens = []
# Track the last complete UTF-8 string (without replacement characters)
last_clean_text = ""
for token_column, token_masks in worker.engine.generate(
tokens,
num_samples=1,
max_tokens=max_new_tokens,
temperature=temperature,
top_k=top_k,
seed=random.randint(0, 2**31 - 1)
):
token = token_column[0]
# Stopping criteria
if token == assistant_end or token == bos:
break
# Append the token to sequence
accumulated_tokens.append(token)
# Decode all accumulated tokens to get proper UTF-8 handling
# Note that decode is a quite efficient operation, basically table lookup and string concat
current_text = worker.tokenizer.decode(accumulated_tokens)
# Only emit text if it doesn't end with a replacement character
# This ensures we don't emit incomplete UTF-8 sequences
if not current_text.endswith('�'):
# Extract only the new text since last clean decode
new_text = current_text[len(last_clean_text):]
if new_text: # Only yield if there's new content
yield f"data: {json.dumps({'token': new_text, 'gpu': worker.gpu_id}, ensure_ascii=False)}\n\n"
last_clean_text = current_text
yield f"data: {json.dumps({'done': True})}\n\n"
@app.post("/chat/completions")
async def chat_completions(request: ChatRequest):
# Basic validation to prevent abuse
validate_chat_request(request)
# Log incoming conversation to console
logger.info("="*20)
for i, message in enumerate(request.messages):
logger.info(f"[{message.role.upper()}]: {message.content}")
logger.info("-"*20)
# Acquire a worker from the pool (will wait if all are busy)
worker_pool = app.state.worker_pool
worker = await worker_pool.acquire_worker()
try:
# Build conversation tokens
bos = worker.tokenizer.get_bos_token_id()
user_start = worker.tokenizer.encode_special("<|user_start|>")
user_end = worker.tokenizer.encode_special("<|user_end|>")
assistant_start = worker.tokenizer.encode_special("<|assistant_start|>")
assistant_end = worker.tokenizer.encode_special("<|assistant_end|>")
conversation_tokens = [bos]
for message in request.messages:
if message.role == "user":
conversation_tokens.append(user_start)
conversation_tokens.extend(worker.tokenizer.encode(message.content))
conversation_tokens.append(user_end)
elif message.role == "assistant":
conversation_tokens.append(assistant_start)
conversation_tokens.extend(worker.tokenizer.encode(message.content))
conversation_tokens.append(assistant_end)
conversation_tokens.append(assistant_start)
# Streaming response with worker release after completion
response_tokens = []
async def stream_and_release():
try:
async for chunk in generate_stream(
worker,
conversation_tokens,
temperature=request.temperature,
max_new_tokens=request.max_tokens,
top_k=request.top_k
):
# Accumulate response for logging
chunk_data = json.loads(chunk.replace("data: ", "").strip())
if "token" in chunk_data:
response_tokens.append(chunk_data["token"])
yield chunk
finally:
# Log the assistant response to console
full_response = "".join(response_tokens)
logger.info(f"[ASSISTANT] (GPU {worker.gpu_id}): {full_response}")
logger.info("="*20)
# Release worker back to pool after streaming is done
await worker_pool.release_worker(worker)
return StreamingResponse(
stream_and_release(),
media_type="text/event-stream"
)
except Exception as e:
# Make sure to release worker even on error
await worker_pool.release_worker(worker)
raise e
@app.get("/health")
async def health():
worker_pool = getattr(app.state, 'worker_pool', None)
return {
"status": "ok",
"ready": worker_pool is not None and len(worker_pool.workers) > 0,
"num_gpus": worker_pool.num_gpus if worker_pool else 0,
"available_workers": worker_pool.available_workers.qsize() if worker_pool else 0
}
@app.get("/stats")
async def stats():
worker_pool = app.state.worker_pool
return {
"total_workers": len(worker_pool.workers),
"available_workers": worker_pool.available_workers.qsize(),
"busy_workers": len(worker_pool.workers) - worker_pool.available_workers.qsize(),
"workers": [
{
"gpu_id": w.gpu_id,
"device": str(w.device)
} for w in worker_pool.workers
]
}
if __name__ == "__main__":
import uvicorn
print(f"Starting NanoChat Web Server")
print(f"Temperature: {args.temperature}, Top-k: {args.top_k}, Max tokens: {args.max_tokens}")
uvicorn.run(app, host=args.host, port=args.port) | --- +++ @@ -1,4 +1,34 @@ #!/usr/bin/env python3
+"""
+Unified web chat server - serves both UI and API from a single FastAPI instance.
+
+Uses data parallelism to distribute requests across multiple GPUs. Each GPU loads
+a full copy of the model, and incoming requests are distributed to available workers.
+
+Launch examples:
+
+- single available GPU (default)
+python -m scripts.chat_web
+
+- 4 GPUs
+python -m scripts.chat_web --num-gpus 4
+
+To chat, open the URL printed in the console. (If on cloud box, make sure to use public IP)
+
+Endpoints:
+ GET / - Chat UI
+ POST /chat/completions - Chat API (streaming only)
+ GET /health - Health check with worker pool status
+ GET /stats - Worker pool statistics and GPU utilization
+
+Abuse Prevention:
+ - Maximum 500 messages per request
+ - Maximum 8000 characters per message
+ - Maximum 32000 characters total conversation length
+ - Temperature clamped to 0.0-2.0
+ - Top-k clamped to 0-200 (0 disables top-k filtering, using full vocabulary)
+ - Max tokens clamped to 1-4096
+"""
import argparse
import json
@@ -55,12 +85,14 @@
@dataclass
class Worker:
+ """A worker with a model loaded on a specific GPU."""
gpu_id: int
device: torch.device
engine: Engine
tokenizer: object
class WorkerPool:
+ """Pool of workers, each with a model replica on a different GPU."""
def __init__(self, num_gpus: Optional[int] = None):
if num_gpus is None:
@@ -73,6 +105,7 @@ self.available_workers: asyncio.Queue = asyncio.Queue()
async def initialize(self, source: str, model_tag: Optional[str] = None, step: Optional[int] = None):
+ """Load model on each GPU."""
print(f"Initializing worker pool with {self.num_gpus} GPUs...")
if self.num_gpus > 1:
assert device_type == "cuda", "Only CUDA supports multiple workers/GPUs. cpu|mps does not."
@@ -100,9 +133,11 @@ print(f"All {self.num_gpus} workers initialized!")
async def acquire_worker(self) -> Worker:
+ """Get an available worker from the pool."""
return await self.available_workers.get()
async def release_worker(self, worker: Worker):
+ """Return a worker to the pool."""
await self.available_workers.put(worker)
class ChatMessage(BaseModel):
@@ -116,6 +151,7 @@ top_k: Optional[int] = None
def validate_chat_request(request: ChatRequest):
+ """Validate chat request to prevent abuse."""
# Check number of messages
if len(request.messages) == 0:
raise HTTPException(status_code=400, detail="At least one message is required")
@@ -179,6 +215,7 @@
@asynccontextmanager
async def lifespan(app: FastAPI):
+ """Load models on all GPUs on startup."""
print("Loading nanochat models across GPUs...")
app.state.worker_pool = WorkerPool(num_gpus=args.num_gpus)
await app.state.worker_pool.initialize(args.source, model_tag=args.model_tag, step=args.step)
@@ -197,6 +234,7 @@
@app.get("/")
async def root():
+ """Serve the chat UI."""
ui_html_path = os.path.join("nanochat", "ui.html")
with open(ui_html_path, "r", encoding="utf-8") as f:
html_content = f.read()
@@ -210,6 +248,7 @@
@app.get("/logo.svg")
async def logo():
+ """Serve the NanoChat logo for favicon and header."""
logo_path = os.path.join("nanochat", "logo.svg")
return FileResponse(logo_path, media_type="image/svg+xml")
@@ -220,6 +259,7 @@ max_new_tokens=None,
top_k=None
) -> AsyncGenerator[str, None]:
+ """Generate assistant response with streaming."""
temperature = temperature if temperature is not None else args.temperature
max_new_tokens = max_new_tokens if max_new_tokens is not None else args.max_tokens
top_k = top_k if top_k is not None else args.top_k
@@ -264,6 +304,7 @@
@app.post("/chat/completions")
async def chat_completions(request: ChatRequest):
+ """Chat completion endpoint (streaming only) - uses worker pool for multi-GPU."""
# Basic validation to prevent abuse
validate_chat_request(request)
@@ -334,6 +375,7 @@
@app.get("/health")
async def health():
+ """Health check endpoint."""
worker_pool = getattr(app.state, 'worker_pool', None)
return {
"status": "ok",
@@ -344,6 +386,7 @@
@app.get("/stats")
async def stats():
+ """Get worker pool statistics."""
worker_pool = app.state.worker_pool
return {
"total_workers": len(worker_pool.workers),
@@ -361,4 +404,4 @@ import uvicorn
print(f"Starting NanoChat Web Server")
print(f"Temperature: {args.temperature}, Top-k: {args.top_k}, Max tokens: {args.max_tokens}")
- uvicorn.run(app, host=args.host, port=args.port)+ uvicorn.run(app, host=args.host, port=args.port)
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/chat_web.py |
Write proper docstrings for these functions |
import argparse
import os
import itertools
import wandb
import torch
import torch.distributed as dist
from nanochat.common import compute_init, compute_cleanup, print0, get_base_dir, DummyWandb, autodetect_device_type
from nanochat.checkpoint_manager import save_checkpoint, load_model
from nanochat.engine import Engine
from tasks.gsm8k import GSM8K
# -----------------------------------------------------------------------------
# CLI arguments
parser = argparse.ArgumentParser(description="Reinforcement learning on GSM8K")
# Logging
parser.add_argument("--run", type=str, default="dummy", help="wandb run name ('dummy' disables wandb logging)")
# Runtime
parser.add_argument("--device-type", type=str, default="", help="cuda|cpu|mps (empty = autodetect)")
# Model loading
parser.add_argument("--model-tag", type=str, default=None, help="model tag to load from")
parser.add_argument("--model-step", type=int, default=None, help="model step to load from")
# Training horizon
parser.add_argument("--num-epochs", type=int, default=1, help="number of epochs over GSM8K")
# Batch sizes / sampling
parser.add_argument("--device-batch-size", type=int, default=8, help="max batch size per forward pass")
parser.add_argument("--examples-per-step", type=int, default=16, help="total examples per optimization step across all ranks")
parser.add_argument("--num-samples", type=int, default=16, help="number of samples per example/question")
# Generation
parser.add_argument("--max-new-tokens", type=int, default=256, help="max tokens to generate per sample")
parser.add_argument("--temperature", type=float, default=1.0, help="sampling temperature")
parser.add_argument("--top-k", type=int, default=50, help="top-k sampling (0 = disabled)")
# Optimization
parser.add_argument("--embedding-lr", type=float, default=0.2, help="learning rate for embedding parameters (Adam)")
parser.add_argument("--unembedding-lr", type=float, default=0.004, help="learning rate for unembedding parameters (Adam)")
parser.add_argument("--matrix-lr", type=float, default=0.02, help="learning rate for matrix parameters (Muon)")
parser.add_argument("--weight-decay", type=float, default=0.0, help="weight decay for embedding/unembedding parameters (Adam)")
parser.add_argument("--init-lr-frac", type=float, default=0.05, help="initial LR as fraction of base LR")
# Evaluation / checkpointing
parser.add_argument("--eval-every", type=int, default=60, help="evaluate pass@k every N steps")
parser.add_argument("--eval-examples", type=int, default=400, help="number of examples for pass@k evaluation")
parser.add_argument("--save-every", type=int, default=60, help="save checkpoint every N steps")
args = parser.parse_args()
user_config = vars(args).copy()
# -----------------------------------------------------------------------------
# Init compute/precision
device_type = autodetect_device_type() if args.device_type == "" else args.device_type
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
# wandb logging init
use_dummy_wandb = args.run == "dummy" or not master_process
wandb_run = DummyWandb() if use_dummy_wandb else wandb.init(project="nanochat-rl", name=args.run, config=user_config)
# Init model and tokenizer
model, tokenizer, meta = load_model("sft", device, phase="eval", model_tag=args.model_tag, step=args.model_step)
engine = Engine(model, tokenizer) # for sampling rollouts
# -----------------------------------------------------------------------------
# Rollout / sampling generator loop that yields batches of examples for training
train_task = GSM8K(subset="main", split="train")
val_task = GSM8K(subset="main", split="test")
num_steps = (len(train_task) // args.examples_per_step) * args.num_epochs
print0(f"Calculated number of steps: {num_steps}")
@torch.no_grad()
def get_batch():
assistant_end = tokenizer.encode_special("<|assistant_end|>") # ok to use this token, it's only for padding and isn't used in the loss.
rank_indices = range(ddp_rank, len(train_task), ddp_world_size) # each rank is responsible for different examples in the training data
for example_idx in itertools.cycle(rank_indices):
# First get the full conversation of both user and assistant messages
conversation = train_task[example_idx]
# Tokenize the conversation, deleting the last Assistant message and priming the Assistant for a completion instead
# (i.e. keep the <|assistant_start|>, but delete everything after it)
tokens = tokenizer.render_for_completion(conversation)
prefix_length = len(tokens)
# Generate num_samples samples using batched generation, use loop to avoid OOMs
model.eval() # ensure the model is in eval mode
generated_token_sequences = []
masks = []
num_sampling_steps = args.num_samples // args.device_batch_size # go sequentially to prevent OOMs
for sampling_step in range(num_sampling_steps):
seed = hash((step, example_idx, sampling_step)) & 0x7FFFFFFF # positive half of int32
generated_token_sequences_batch, masks_batch = engine.generate_batch(
tokens,
num_samples=args.device_batch_size,
max_tokens=args.max_new_tokens,
temperature=args.temperature,
top_k=args.top_k,
seed=seed, # must make sure to change the seed for each sampling step
)
generated_token_sequences.extend(generated_token_sequences_batch)
masks.extend(masks_batch)
# Calculate the rewards for each sample
rewards = []
for sample_tokens in generated_token_sequences:
# Get just the generated tokens (after the prompt)
generated_tokens = sample_tokens[prefix_length:]
# Decode the generated response
generated_text = tokenizer.decode(generated_tokens)
# Calculate the reward
reward = train_task.reward(conversation, generated_text)
rewards.append(reward)
# Pad the sequences so that their lengths (in time) match
max_length = max(len(seq) for seq in generated_token_sequences)
padded_generated_token_sequences = [seq + [assistant_end] * (max_length - len(seq)) for seq in generated_token_sequences]
padded_masks = [mask + [0] * (max_length - len(mask)) for mask in masks]
# Stack up the sequences and masks into PyTorch tensors
ids = torch.tensor(padded_generated_token_sequences, dtype=torch.long, device=device)
mask_ids = torch.tensor(padded_masks, dtype=torch.long, device=device)
# Generate autoregressive inputs and targets to the Transformer
inputs = ids[:, :-1]
targets = ids[:, 1:].clone() # clone to avoid in-place modification:
targets[mask_ids[:, 1:] == 0] = -1 # <-- inplace modification right here. -1 is the ignore index
# NOTE also that the Engine returns mask=0 for BOTH the prompt tokens AND the tool use tokens.
# So we will (correctly) end up not training on the prompt tokens, or the tool use forced tokens.
rewards = torch.tensor(rewards, dtype=torch.float, device=device)
# Calculate the advantages by simply subtracting the mean (instead of z-score (x-mu)/sigma)
mu = rewards.mean()
advantages = rewards - mu
# yield inputs/targets as (B, T) of ids and rewards as (B,) of floats
yield generated_token_sequences, inputs, targets, rewards, advantages
# -----------------------------------------------------------------------------
# Simple evaluation loop for GSM8K pass@k
def run_gsm8k_eval(task, tokenizer, engine,
max_examples=None,
num_samples=1,
max_completion_tokens=256,
temperature=0.0,
top_k=50
):
max_examples = min(max_examples, len(task)) if max_examples is not None else len(task)
for idx in range(ddp_rank, max_examples, ddp_world_size):
conversation = task[idx]
tokens = tokenizer.render_for_completion(conversation)
prefix_length = len(tokens)
# Generate k samples using batched generation inside the Engine
assert num_samples <= args.device_batch_size # usually this is true. we can add a loop if not...
generated_token_sequences, masks = engine.generate_batch(
tokens,
num_samples=num_samples,
max_tokens=max_completion_tokens,
temperature=temperature,
top_k=top_k
)
# Check each sample for correctness
outcomes = []
for sample_tokens in generated_token_sequences:
generated_tokens = sample_tokens[prefix_length:]
generated_text = tokenizer.decode(generated_tokens)
is_correct = task.evaluate(conversation, generated_text)
outcomes.append({
"is_correct": is_correct
})
# A bit bloated because I wanted to do more complex logging at one point.
record = {
"idx": idx,
"outcomes": outcomes,
}
yield record
# -----------------------------------------------------------------------------
# Training loop
# Init the optimizer
optimizer = model.setup_optimizer(
unembedding_lr=args.unembedding_lr,
embedding_lr=args.embedding_lr,
matrix_lr=args.matrix_lr,
weight_decay=args.weight_decay,
)
# Set the initial learning rate as a fraction of the base learning rate
for group in optimizer.param_groups:
group["lr"] = group["lr"] * args.init_lr_frac
group["initial_lr"] = group["lr"]
# Learning rate scheduler: simple rampdown to zero over num_steps
def get_lr_multiplier(it):
lrm = 1.0 - it / num_steps
return lrm
# Calculate the number of examples each rank handles to achieve the desired examples_per_step
print0(f"Total sequences per step: {args.examples_per_step * args.num_samples}") # total batch size in sequences/step
assert args.examples_per_step % ddp_world_size == 0, "Desired examples per step must be divisible by the number of ranks"
examples_per_rank = args.examples_per_step // ddp_world_size # per GPU
print0(f"Calculated examples per rank: {examples_per_rank}")
# Kick off the training loop
batch_iterator = get_batch()
for step in range(num_steps):
# Evaluate the model once in a while and log to wandb
if step % args.eval_every == 0:
model.eval()
passk = torch.zeros(args.device_batch_size, device=device) # pass@k for k=1..device_batch_size
records_iter = run_gsm8k_eval(val_task, tokenizer, engine, num_samples=args.device_batch_size, max_examples=args.eval_examples, temperature=1.0)
records = list(records_iter) # collect all records
for k in range(1, args.device_batch_size + 1):
passk[k - 1] = sum(any(o["is_correct"] for o in r["outcomes"][:k]) for r in records)
num_records = torch.tensor(len(records), dtype=torch.long, device=device)
if ddp:
dist.all_reduce(num_records, op=dist.ReduceOp.SUM)
dist.all_reduce(passk, op=dist.ReduceOp.SUM)
passk = passk / num_records.item() # normalize by the total number of records
print_passk = [f"Pass@{k}: {passk[k - 1].item():.4f}" for k in range(1, args.device_batch_size + 1)]
print0(f"Step {step} | {', '.join(print_passk)}")
log_passk = {f"pass@{k}": passk[k - 1].item() for k in range(1, args.device_batch_size + 1)}
wandb_run.log({
"step": step,
**log_passk,
})
# Forward/Backward on rollouts over multiple examples in the dataset
rewards_list = []
sequence_lengths = []
for example_step in range(examples_per_rank):
# Get one batch corresponding to one example in the training dataset
sequences_all, inputs_all, targets_all, rewards_all, advantages_all = next(batch_iterator)
# Evaluate the loss and gradients
model.train() # ensure the model is in train mode
# We need one more loop because we can never exceed the device_batch_size
assert inputs_all.size(0) % args.device_batch_size == 0
num_passes = inputs_all.size(0) // args.device_batch_size
for pass_idx in range(num_passes):
# Pluck out the batch for this pass
b0, b1 = pass_idx * args.device_batch_size, (pass_idx + 1) * args.device_batch_size
inputs = inputs_all[b0:b1]
targets = targets_all[b0:b1]
rewards = rewards_all[b0:b1]
advantages = advantages_all[b0:b1]
# Calculate log probabilities. Note that the loss calculates NLL = -logp, so we negate
logp = -model(inputs, targets, loss_reduction='none').view_as(inputs) # (B, T)
# Calculate the PG objective. Note that ignore_index=-1 ensures that invalid tokens have loss 0.
pg_obj = (logp * advantages.unsqueeze(-1)).sum()
# normalize by the number of valid tokens, number of passes, and examples_per_rank
num_valid = (targets >= 0).sum().clamp(min=1)
pg_obj = pg_obj / (num_valid * num_passes * examples_per_rank)
# Note, there is no need to add PPO ratio+clip because we are on policy
# Finally, formulate the loss that we want to minimize (instead of objective we wish to maximize)
loss = -pg_obj
loss.backward()
print0(f"Step {step}/{num_steps} | Example step {example_step} | Pass {pass_idx} | loss: {loss.item():.6f} | Average reward: {rewards.mean().item()}")
# For logging
rewards_list.append(rewards_all.mean().item())
sequence_lengths.extend(len(seq) for seq in sequences_all)
# A bunch of logging for how the rollouts went this step
mean_reward = sum(rewards_list) / len(rewards_list)
mean_sequence_length = sum(sequence_lengths) / len(sequence_lengths)
if ddp: # aggregate across ranks
mean_reward_tensor = torch.tensor(mean_reward, dtype=torch.float, device=device)
mean_sequence_length_tensor = torch.tensor(mean_sequence_length, dtype=torch.float, device=device)
dist.all_reduce(mean_reward_tensor, op=dist.ReduceOp.AVG)
dist.all_reduce(mean_sequence_length_tensor, op=dist.ReduceOp.AVG)
mean_reward = mean_reward_tensor.item()
mean_sequence_length = mean_sequence_length_tensor.item()
print0(f"Step {step}/{num_steps} | Average reward: {mean_reward} | Average sequence length: {mean_sequence_length:.2f}")
wandb_run.log({
"step": step,
"reward": mean_reward,
"sequence_length": mean_sequence_length,
})
# Update the model parameters
lrm = get_lr_multiplier(step)
for group in optimizer.param_groups:
group["lr"] = group["initial_lr"] * lrm
optimizer.step()
model.zero_grad(set_to_none=True)
wandb_run.log({
"step": step,
"lrm": lrm,
})
# Master process saves the model once in a while. Skip first step. Save last step.
if master_process and ((step > 0 and step % args.save_every == 0) or step == num_steps - 1):
base_dir = get_base_dir()
depth = model.config.n_layer
output_dirname = args.model_tag if args.model_tag else f"d{depth}" # base the model tag on the depth of the base model
checkpoint_dir = os.path.join(base_dir, "chatrl_checkpoints", output_dirname)
model_config_kwargs = model.config.__dict__ # slightly naughty, abusing the simplicity of GPTConfig, TODO nicer
save_checkpoint(
checkpoint_dir,
step,
model.state_dict(),
None, # note: we don't bother to save the optimizer state
{
"model_config": model_config_kwargs,
}
)
print(f"✅ Saved model checkpoint to {checkpoint_dir}")
# Log to report
from nanochat.report import get_report
get_report().log(section="Chat RL", data=[
user_config, # CLI args
])
wandb_run.finish() # wandb run finish
compute_cleanup() | --- +++ @@ -1,3 +1,20 @@+"""
+Reinforcement learning on GSM8K via "GRPO".
+
+I put GRPO in quotes because we actually end up with something a lot
+simpler and more similar to just REINFORCE:
+
+1) Delete trust region, so there is no KL regularization to a reference model
+2) We are on policy, so there's no need for PPO ratio+clip.
+3) We use DAPO style normalization that is token-level, not sequence-level.
+4) Instead of z-score normalization (r - mu)/sigma, only use (r - mu) as the advantage.
+
+1 GPU:
+python -m scripts.chat_rl
+
+8 GPUs:
+torchrun --standalone --nproc_per_node=8 -m scripts.chat_rl -- --run=default
+"""
import argparse
import os
@@ -137,6 +154,12 @@ temperature=0.0,
top_k=50
):
+ """
+ Evaluates GSM8K task and returns a list of records of evaluation outcomes.
+ In a distributed setting, all ranks cooperate but this function will NOT
+ do the reduction across ranks. This is the responsibility of the caller.
+ Because the evaluation can take a while, this function will yield records one by one.
+ """
max_examples = min(max_examples, len(task)) if max_examples is not None else len(task)
for idx in range(ddp_rank, max_examples, ddp_world_size):
conversation = task[idx]
@@ -306,4 +329,4 @@ ])
wandb_run.finish() # wandb run finish
-compute_cleanup()+compute_cleanup()
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/chat_rl.py |
Expand my code with proper documentation strings | from sqlalchemy.orm import Session
from sqlalchemy import func
from typing import List, Optional
from datetime import datetime
from app.backend.database.models import ApiKey
class ApiKeyRepository:
def __init__(self, db: Session):
self.db = db
def create_or_update_api_key(
self,
provider: str,
key_value: str,
description: str = None,
is_active: bool = True
) -> ApiKey:
# Check if API key already exists for this provider
existing_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if existing_key:
# Update existing key
existing_key.key_value = key_value
existing_key.description = description
existing_key.is_active = is_active
existing_key.updated_at = func.now()
self.db.commit()
self.db.refresh(existing_key)
return existing_key
else:
# Create new key
api_key = ApiKey(
provider=provider,
key_value=key_value,
description=description,
is_active=is_active
)
self.db.add(api_key)
self.db.commit()
self.db.refresh(api_key)
return api_key
def get_api_key_by_provider(self, provider: str) -> Optional[ApiKey]:
return self.db.query(ApiKey).filter(
ApiKey.provider == provider,
ApiKey.is_active == True
).first()
def get_all_api_keys(self, include_inactive: bool = False) -> List[ApiKey]:
query = self.db.query(ApiKey)
if not include_inactive:
query = query.filter(ApiKey.is_active == True)
return query.order_by(ApiKey.provider).all()
def update_api_key(
self,
provider: str,
key_value: str = None,
description: str = None,
is_active: bool = None
) -> Optional[ApiKey]:
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return None
if key_value is not None:
api_key.key_value = key_value
if description is not None:
api_key.description = description
if is_active is not None:
api_key.is_active = is_active
api_key.updated_at = func.now()
self.db.commit()
self.db.refresh(api_key)
return api_key
def delete_api_key(self, provider: str) -> bool:
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return False
self.db.delete(api_key)
self.db.commit()
return True
def deactivate_api_key(self, provider: str) -> bool:
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return False
api_key.is_active = False
api_key.updated_at = func.now()
self.db.commit()
return True
def update_last_used(self, provider: str) -> bool:
api_key = self.db.query(ApiKey).filter(
ApiKey.provider == provider,
ApiKey.is_active == True
).first()
if not api_key:
return False
api_key.last_used = func.now()
self.db.commit()
return True
def bulk_create_or_update(self, api_keys_data: List[dict]) -> List[ApiKey]:
results = []
for data in api_keys_data:
api_key = self.create_or_update_api_key(
provider=data['provider'],
key_value=data['key_value'],
description=data.get('description'),
is_active=data.get('is_active', True)
)
results.append(api_key)
return results | --- +++ @@ -7,6 +7,7 @@
class ApiKeyRepository:
+ """Repository for API key database operations"""
def __init__(self, db: Session):
self.db = db
@@ -18,6 +19,7 @@ description: str = None,
is_active: bool = True
) -> ApiKey:
+ """Create a new API key or update existing one"""
# Check if API key already exists for this provider
existing_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
@@ -44,12 +46,14 @@ return api_key
def get_api_key_by_provider(self, provider: str) -> Optional[ApiKey]:
+ """Get API key by provider name"""
return self.db.query(ApiKey).filter(
ApiKey.provider == provider,
ApiKey.is_active == True
).first()
def get_all_api_keys(self, include_inactive: bool = False) -> List[ApiKey]:
+ """Get all API keys"""
query = self.db.query(ApiKey)
if not include_inactive:
query = query.filter(ApiKey.is_active == True)
@@ -62,6 +66,7 @@ description: str = None,
is_active: bool = None
) -> Optional[ApiKey]:
+ """Update an existing API key"""
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return None
@@ -79,6 +84,7 @@ return api_key
def delete_api_key(self, provider: str) -> bool:
+ """Delete an API key by provider"""
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return False
@@ -88,6 +94,7 @@ return True
def deactivate_api_key(self, provider: str) -> bool:
+ """Deactivate an API key instead of deleting it"""
api_key = self.db.query(ApiKey).filter(ApiKey.provider == provider).first()
if not api_key:
return False
@@ -98,6 +105,7 @@ return True
def update_last_used(self, provider: str) -> bool:
+ """Update the last_used timestamp for an API key"""
api_key = self.db.query(ApiKey).filter(
ApiKey.provider == provider,
ApiKey.is_active == True
@@ -110,6 +118,7 @@ return True
def bulk_create_or_update(self, api_keys_data: List[dict]) -> List[ApiKey]:
+ """Bulk create or update multiple API keys"""
results = []
for data in api_keys_data:
api_key = self.create_or_update_api_key(
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/repositories/api_key_repository.py |
Improve my code by adding docstrings |
import gc
import argparse
import os
os.environ["PYTORCH_ALLOC_CONF"] = "expandable_segments:True"
import time
import wandb
import torch
from nanochat.common import compute_init, compute_cleanup, print0, DummyWandb, get_base_dir, autodetect_device_type, get_peak_flops, COMPUTE_DTYPE, COMPUTE_DTYPE_REASON, is_ddp_initialized
from nanochat.tokenizer import get_token_bytes
from nanochat.checkpoint_manager import save_checkpoint, load_model, load_optimizer_state
from nanochat.loss_eval import evaluate_bpb
import torch.distributed as dist
from nanochat.flash_attention import HAS_FA3
from nanochat.engine import Engine
from scripts.chat_eval import run_chat_eval
from tasks.common import TaskMixture
from tasks.gsm8k import GSM8K
from tasks.mmlu import MMLU
from tasks.smoltalk import SmolTalk
from tasks.customjson import CustomJSON
from tasks.spellingbee import SimpleSpelling, SpellingBee
# -----------------------------------------------------------------------------
# CLI arguments
parser = argparse.ArgumentParser(description="Supervised fine-tuning (SFT) the model")
# Logging
parser.add_argument("--run", type=str, default="dummy", help="wandb run name ('dummy' disables wandb logging)")
# Runtime
parser.add_argument("--device-type", type=str, default="", help="cuda|cpu|mps (empty = autodetect)")
# Model loading
parser.add_argument("--model-tag", type=str, default=None, help="model tag to load from")
parser.add_argument("--model-step", type=int, default=None, help="model step to load from")
parser.add_argument("--load-optimizer", type=int, default=1, help="warm-start optimizer from pretrained checkpoint (0=no, 1=yes)")
# Training horizon
parser.add_argument("--num-iterations", type=int, default=-1, help="number of optimization steps (-1 = full epoch)")
# Batch sizes (default: inherit from pretrained checkpoint)
parser.add_argument("--max-seq-len", type=int, default=None, help="max context length (default: inherit from pretrain)")
parser.add_argument("--device-batch-size", type=int, default=None, help="per-device batch size (default: inherit from pretrain)")
parser.add_argument("--total-batch-size", type=int, default=None, help="total batch size in tokens (default: inherit from pretrain)")
# Optimization (default: inherit from pretrained checkpoint)
parser.add_argument("--embedding-lr", type=float, default=None, help="learning rate for embedding parameters (Adam) (default: inherit from pretrain)")
parser.add_argument("--unembedding-lr", type=float, default=None, help="learning rate for unembedding parameters (Adam) (default: inherit from pretrain)")
parser.add_argument("--matrix-lr", type=float, default=None, help="learning rate for matrix parameters (Muon) (default: inherit from pretrain)")
parser.add_argument("--init-lr-frac", type=float, default=0.8, help="initial LR as fraction of base LR")
parser.add_argument("--warmup-ratio", type=float, default=0.0, help="ratio of iterations for LR warmup")
parser.add_argument("--warmdown-ratio", type=float, default=0.5, help="ratio of iterations for LR warmdown")
parser.add_argument("--final-lr-frac", type=float, default=0.0, help="final LR as fraction of initial LR")
# Evaluation
parser.add_argument("--eval-every", type=int, default=200, help="evaluate val bpb every N steps (-1 = disable)")
parser.add_argument("--eval-tokens", type=int, default=40*524288, help="number of tokens to evaluate val loss on")
parser.add_argument("--chatcore-every", type=int, default=200, help="evaluate ChatCORE metric every N steps (-1 = disable)")
parser.add_argument("--chatcore-max-cat", type=int, default=-1, help="max problems per categorical task for ChatCORE")
parser.add_argument("--chatcore-max-sample", type=int, default=24, help="max problems per generative task for ChatCORE")
# Data mixture
parser.add_argument("--mmlu-epochs", type=int, default=3, help="number of epochs of MMLU in training mixture (teaches Multiple Choice)")
parser.add_argument("--gsm8k-epochs", type=int, default=4, help="number of epochs of GSM8K in training mixture (teaches Math and Tool Use)")
args = parser.parse_args()
user_config = vars(args).copy()
# -----------------------------------------------------------------------------
# Compute init
device_type = autodetect_device_type() if args.device_type == "" else args.device_type
ddp, ddp_rank, ddp_local_rank, ddp_world_size, device = compute_init(device_type)
master_process = ddp_rank == 0
print0(f"COMPUTE_DTYPE: {COMPUTE_DTYPE} ({COMPUTE_DTYPE_REASON})")
synchronize = torch.cuda.synchronize if device_type == "cuda" else lambda: None
get_max_memory = torch.cuda.max_memory_allocated if device_type == "cuda" else lambda: 0
if device_type == "cuda":
gpu_device_name = torch.cuda.get_device_name(0)
gpu_peak_flops = get_peak_flops(gpu_device_name)
print0(f"GPU: {gpu_device_name} | Peak FLOPS (BF16): {gpu_peak_flops:.2e}")
else:
gpu_peak_flops = float('inf') # MFU not meaningful for CPU/MPS
# wandb logging init
use_dummy_wandb = args.run == "dummy" or not master_process
wandb_run = DummyWandb() if use_dummy_wandb else wandb.init(project="nanochat-sft", name=args.run, config=user_config)
# Flash Attention status
if not HAS_FA3:
print0("WARNING: Flash Attention 3 not available, using PyTorch SDPA fallback. Training will be less efficient.")
# Load the model and tokenizer
model, tokenizer, meta = load_model("base", device, phase="train", model_tag=args.model_tag, step=args.model_step)
# Inherit training hyperparameters from pretrained checkpoint (None = inherit, explicit value = override)
pretrain_user_config = meta.get("user_config", {})
for name, fallback, source in [
("max_seq_len", 2048, meta),
("device_batch_size", 32, meta),
("total_batch_size", 524288, meta),
("embedding_lr", 0.3, pretrain_user_config),
("unembedding_lr", 0.004, pretrain_user_config),
("matrix_lr", 0.02, pretrain_user_config),
]:
arg_val = getattr(args, name)
pretrain_val = source.get(name)
if arg_val is None:
resolved = pretrain_val if pretrain_val is not None else fallback
setattr(args, name, resolved)
print0(f"Inherited {name}={resolved} from pretrained checkpoint")
elif pretrain_val is not None and arg_val != pretrain_val:
print0(f"NOTE: --{name.replace('_', '-')}={arg_val} overrides pretrained value of {pretrain_val}")
else:
print0(f"Using {name}={arg_val}")
orig_model = model
model = torch.compile(model, dynamic=False)
depth = model.config.n_layer
num_flops_per_token = model.estimate_flops()
tokens_per_fwdbwd = args.device_batch_size * args.max_seq_len # tokens per iteration for a single rank
world_tokens_per_fwdbwd = tokens_per_fwdbwd * ddp_world_size # total tokens per iteration for all ranks
assert args.total_batch_size % world_tokens_per_fwdbwd == 0
grad_accum_steps = args.total_batch_size // world_tokens_per_fwdbwd
print0(f"Tokens / micro-batch / rank: {args.device_batch_size} x {args.max_seq_len} = {tokens_per_fwdbwd:,}")
print0(f"Tokens / micro-batch: {world_tokens_per_fwdbwd:,}")
print0(f"Total batch size {args.total_batch_size:,} => gradient accumulation steps: {grad_accum_steps}")
token_bytes = get_token_bytes(device=device)
# Initialize the Optimizer (combined MuonAdamW: Muon for matrix params, AdamW for rest)
# Note that pretraining ramps weight_decay to zero by end of pretraining, so SFT continues with zero
optimizer = model.setup_optimizer(unembedding_lr=args.unembedding_lr, embedding_lr=args.embedding_lr, matrix_lr=args.matrix_lr, weight_decay=0.0)
# Optionally warm-start optimizer from pretrained checkpoint (momentum buffers etc.)
# Note: load_state_dict overwrites param_group metadata (LRs, betas, etc.) with the
# pretrained values. Since pretraining warmdown brings LRs to ~0, we must save and
# restore our fresh SFT LRs after loading.
base_dir = get_base_dir()
if args.load_optimizer:
optimizer_data = load_optimizer_state("base", device, rank=ddp_rank, model_tag=args.model_tag, step=args.model_step)
if optimizer_data is not None:
base_lrs = [group["lr"] for group in optimizer.param_groups]
optimizer.load_state_dict(optimizer_data)
del optimizer_data
for group, base_lr in zip(optimizer.param_groups, base_lrs):
group["lr"] = base_lr
print0("Loaded optimizer state from pretrained checkpoint (momentum buffers only, LRs reset)")
else:
print0("WARNING: optimizer checkpoint not found, starting with fresh optimizer (slightly worse)")
# GradScaler for fp16 training (bf16/fp32 don't need it)
scaler = torch.amp.GradScaler() if COMPUTE_DTYPE == torch.float16 else None
if scaler is not None:
print0("GradScaler enabled for fp16 training")
# Override the initial learning rate as a fraction of the base learning rate
for group in optimizer.param_groups:
group["lr"] = group["lr"] * args.init_lr_frac
group["initial_lr"] = group["lr"]
# SFT data mixture and DataLoader
identity_conversations_filepath = os.path.join(base_dir, "identity_conversations.jsonl")
train_tasks = [
SmolTalk(split="train"), # 460K rows of general conversations
CustomJSON(filepath=identity_conversations_filepath), # 1000 rows of synthetic identity conversations
CustomJSON(filepath=identity_conversations_filepath), # 2 epochs of these
*[MMLU(subset="auxiliary_train", split="train") for _ in range(args.mmlu_epochs)], # 100K rows per epoch
*[GSM8K(subset="main", split="train") for _ in range(args.gsm8k_epochs)], # 8K rows per epoch
SimpleSpelling(size=200000, split="train"), # 200K rows of Simple Spelling (e.g. spell the word 'apple')
SpellingBee(size=80000, split="train"), # 80K rows of Spelling Bee (e.g. how many 'r' are in 'strawberry'?)
]
train_dataset = TaskMixture(train_tasks)
print0(f"Training mixture: {len(train_dataset):,} rows (MMLU x{args.mmlu_epochs}, GSM8K x{args.gsm8k_epochs})")
val_dataset = TaskMixture([
SmolTalk(split="test"), # 24K rows in test set
MMLU(subset="all", split="test", stop=5200), # 14K rows in test set, use only 5.2K to match the train ratios
GSM8K(subset="main", split="test", stop=420), # 1.32K rows in test set, use only 420 to match the train ratios
]) # total: 24K + 14K + 1.32K ~= 39K rows
# DataLoader is defined here, it emits inputs, targets : 2D tensors of shape (device_batch_size, max_seq_len)
# A big problem is that we don't know the final num_iterations in advance. So we create
# these two global variables and update them from within the data generator.
last_step = False # we will toggle this to True when we reach the end of the training dataset
approx_progress = 0.0 # will go from 0 to 1 over the course of the epoch
current_epoch = 1 # track epoch for logging
def sft_data_generator_bos_bestfit(split, buffer_size=100):
global last_step, approx_progress, current_epoch
assert split in {"train", "val"}, "split must be 'train' or 'val'"
dataset = train_dataset if split == "train" else val_dataset
dataset_size = len(dataset)
assert dataset_size > 0
row_capacity = args.max_seq_len + 1 # +1 for target at last position
bos_token = tokenizer.get_bos_token_id()
# Conversation buffer: list of (token_ids, loss_mask) tuples
conv_buffer = []
cursor = ddp_rank # Each rank processes different conversations (for fetching)
consumed = ddp_rank # Track actual consumption separately from buffering
epoch = 1
it = 0 # iteration counter
def refill_buffer():
nonlocal cursor, epoch
while len(conv_buffer) < buffer_size:
conversation = dataset[cursor]
ids, mask = tokenizer.render_conversation(conversation)
conv_buffer.append((ids, mask))
cursor += ddp_world_size
if cursor >= dataset_size:
cursor = cursor % dataset_size
epoch += 1
# Note: last_step is now triggered based on consumption, not fetching
while True:
rows = []
mask_rows = []
row_lengths = [] # Track actual content length (excluding padding) for each row
for _ in range(args.device_batch_size):
row = []
mask_row = []
padded = False
while len(row) < row_capacity:
# Ensure buffer has conversations
while len(conv_buffer) < buffer_size:
refill_buffer()
remaining = row_capacity - len(row)
# Find largest conversation that fits entirely
best_idx = -1
best_len = 0
for i, (conv, _) in enumerate(conv_buffer):
conv_len = len(conv)
if conv_len <= remaining and conv_len > best_len:
best_idx = i
best_len = conv_len
if best_idx >= 0:
# Found a conversation that fits - use it entirely
conv, conv_mask = conv_buffer.pop(best_idx)
row.extend(conv)
mask_row.extend(conv_mask)
consumed += ddp_world_size # Track actual consumption
else:
# No conversation fits - pad the remainder instead of cropping
# This ensures we never discard any tokens
content_len = len(row)
row.extend([bos_token] * remaining) # Pad with BOS tokens
mask_row.extend([0] * remaining)
padded = True
break # Row is now full (with padding)
# Track content length: full row if no padding, otherwise the length before padding
if padded:
row_lengths.append(content_len)
else:
row_lengths.append(row_capacity)
rows.append(row[:row_capacity])
mask_rows.append(mask_row[:row_capacity])
# Stopping condition to respect num_iterations, if given
it += 1
if 0 < args.num_iterations <= it and split == "train":
last_step = True
# Update progress tracking (based on consumed, not cursor, to account for buffering)
if split == "train":
current_epoch = epoch
if args.num_iterations > 0:
approx_progress = it / args.num_iterations
else:
approx_progress = consumed / dataset_size
# Trigger last_step when we've consumed enough (instead of when cursor wraps)
if consumed >= dataset_size:
last_step = True
# Build tensors
use_cuda = device_type == "cuda"
batch_tensor = torch.tensor(rows, dtype=torch.long, pin_memory=use_cuda)
inputs = batch_tensor[:, :-1].to(device=device, dtype=torch.int32, non_blocking=use_cuda).contiguous()
targets = batch_tensor[:, 1:].to(device=device, dtype=torch.int64, non_blocking=use_cuda).contiguous()
# Apply the loss mask from render_conversation (mask=1 for assistant completions,
# mask=0 for user prompts, BOS, special tokens, tool outputs). mask[1:] aligns
# with targets (shifted by 1). Unmasked positions get -1 (ignore_index).
mask_tensor = torch.tensor(mask_rows, dtype=torch.int8)
mask_targets = mask_tensor[:, 1:].to(device=device)
targets[mask_targets == 0] = -1
# Mask out padding positions in targets (set to -1 = ignore_index)
# For each row, positions >= (content_length - 1) in targets should be masked
for i, content_len in enumerate(row_lengths):
if content_len < row_capacity:
targets[i, content_len-1:] = -1
yield inputs, targets
train_loader = sft_data_generator_bos_bestfit("train")
build_val_loader = lambda: sft_data_generator_bos_bestfit("val")
progress = 0 # will go from 0 to 1 over the course of the epoch
# Learning rate schedule (linear warmup, constant, linear warmdown)
# Same shape as base_train but uses progress (0→1) instead of absolute step counts,
# because SFT doesn't always know num_iterations in advance (dataset-driven stopping).
def get_lr_multiplier(progress):
if progress < args.warmup_ratio:
return (progress + 1e-8) / args.warmup_ratio
elif progress <= 1.0 - args.warmdown_ratio:
return 1.0
else:
decay = (progress - (1.0 - args.warmdown_ratio)) / args.warmdown_ratio
return (1 - decay) * 1.0 + decay * args.final_lr_frac
# Momentum scheduler for Muon optimizer
def get_muon_momentum(it):
frac = min(it / 300, 1)
momentum = (1 - frac) * 0.85 + frac * 0.95
return momentum
# -----------------------------------------------------------------------------
# Training loop
x, y = next(train_loader) # prefetch the very first batch of data
min_val_bpb = float("inf")
smooth_train_loss = 0 # EMA of training loss
ema_beta = 0.9 # EMA decay factor
total_training_time = 0 # total wall-clock time of training
step = 0
while True:
flops_so_far = num_flops_per_token * args.total_batch_size * step
# Synchronize last_step across all ranks to avoid hangs in the distributed setting
if ddp:
last_step_tensor = torch.tensor(last_step, dtype=torch.int32, device=device)
dist.all_reduce(last_step_tensor, op=dist.ReduceOp.MAX)
last_step = bool(last_step_tensor.item())
# once in a while: evaluate the val bpb (all ranks participate)
if last_step or (args.eval_every > 0 and step % args.eval_every == 0):
model.eval()
val_loader = build_val_loader()
eval_steps = args.eval_tokens // (args.device_batch_size * args.max_seq_len * ddp_world_size)
val_bpb = evaluate_bpb(model, val_loader, eval_steps, token_bytes)
print0(f"Step {step:05d} | Validation bpb: {val_bpb:.4f}")
if val_bpb < min_val_bpb:
min_val_bpb = val_bpb
wandb_run.log({
"step": step,
"total_training_flops": flops_so_far,
"total_training_time": total_training_time,
"val/bpb": val_bpb,
})
model.train()
# once in a while: estimate the ChatCORE metric (all ranks participate)
# use the original uncompiled model because the inputs keep changing shape
chatcore_results = {}
if args.chatcore_every > 0 and (last_step or (step > 0 and step % args.chatcore_every == 0)):
model.eval()
engine = Engine(orig_model, tokenizer)
all_tasks = ['ARC-Easy', 'ARC-Challenge', 'MMLU', 'GSM8K', 'HumanEval', 'SpellingBee']
categorical_tasks = {'ARC-Easy', 'ARC-Challenge', 'MMLU'}
baseline_accuracies = {
'ARC-Easy': 0.25, 'ARC-Challenge': 0.25, 'MMLU': 0.25,
'GSM8K': 0.0, 'HumanEval': 0.0, 'SpellingBee': 0.0,
}
task_results = {}
for task_name in all_tasks:
limit = args.chatcore_max_cat if task_name in categorical_tasks else args.chatcore_max_sample
max_problems = None if limit < 0 else limit # -1 means no limit
acc = run_chat_eval(task_name, orig_model, tokenizer, engine,
batch_size=args.device_batch_size, max_problems=max_problems)
task_results[task_name] = acc
print0(f" {task_name}: {100*acc:.2f}%")
# Compute ChatCORE metrics (mean centered accuracy, ranges from 0=random to 1=perfect)
def centered_mean(tasks):
return sum((task_results[t] - baseline_accuracies[t]) / (1.0 - baseline_accuracies[t]) for t in tasks) / len(tasks)
chatcore = centered_mean(all_tasks)
chatcore_cat = centered_mean(categorical_tasks)
print0(f"Step {step:05d} | ChatCORE: {chatcore:.4f} | ChatCORE_cat: {chatcore_cat:.4f}")
wandb_run.log({
"step": step,
"total_training_flops": flops_so_far,
"chatcore_metric": chatcore,
"chatcore_cat": chatcore_cat,
**{f"chatcore/{task_name}": acc for task_name, acc in task_results.items()},
})
model.train()
# save checkpoint at the end of the run (all ranks participate so each saves its optimizer shard)
if last_step:
output_dirname = args.model_tag if args.model_tag else f"d{depth}" # e.g. d12
checkpoint_dir = os.path.join(base_dir, "chatsft_checkpoints", output_dirname)
save_checkpoint(
checkpoint_dir,
step,
orig_model.state_dict(),
optimizer.state_dict(),
{
"step": step,
"val_bpb": val_bpb, # loss at last step
"model_config": {
"sequence_len": args.max_seq_len,
"vocab_size": tokenizer.get_vocab_size(),
"n_layer": depth,
"n_head": model.config.n_head,
"n_kv_head": model.config.n_kv_head,
"n_embd": model.config.n_embd,
"window_pattern": model.config.window_pattern,
},
"user_config": user_config, # inputs to the training script
},
rank=ddp_rank,
)
if last_step:
break
# -------------------------------------------------------------------------
# single training step
# evaluate the gradient
synchronize()
t0 = time.time()
for micro_step in range(grad_accum_steps):
loss = model(x, y)
train_loss = loss.detach() # for logging
loss = loss / grad_accum_steps # each .backward() is a grad sum => normalize loss here
if scaler is not None:
scaler.scale(loss).backward()
else:
loss.backward()
x, y = next(train_loader) # prefetch the next batch while the GPU is busy with forward/backward
progress = max(progress, approx_progress) # only increase progress monotonically
# step the optimizer
lrm = get_lr_multiplier(progress)
muon_momentum = get_muon_momentum(step)
for group in optimizer.param_groups:
group["lr"] = group["initial_lr"] * lrm
if group['kind'] == 'muon':
group["momentum"] = muon_momentum
if scaler is not None:
scaler.unscale_(optimizer)
if is_ddp_initialized():
for v in scaler._found_inf_per_device(optimizer).values():
dist.all_reduce(v, op=dist.ReduceOp.MAX)
scaler.step(optimizer)
scaler.update()
else:
optimizer.step()
model.zero_grad(set_to_none=True)
synchronize()
t1 = time.time()
dt = t1 - t0
# -------------------------------------------------------------------------
# State
step += 1
# logging
smooth_train_loss = ema_beta * smooth_train_loss + (1 - ema_beta) * train_loss.item() # EMA the training loss
debiased_smooth_loss = smooth_train_loss / (1 - ema_beta**(step + 1)) # debias the EMA
pct_done = 100 * progress
tok_per_sec = int(args.total_batch_size / dt)
flops_per_sec = num_flops_per_token * args.total_batch_size / dt
mfu = 100 * flops_per_sec / (gpu_peak_flops * ddp_world_size)
if step > 10:
total_training_time += dt # only count the time after the first 10 steps
print0(f"step {step:05d} ({pct_done:.2f}%) | loss: {debiased_smooth_loss:.6f} | lrm: {lrm:.2f} | dt: {dt * 1000:.2f}ms | tok/sec: {tok_per_sec:,} | mfu: {mfu:.2f} | epoch: {current_epoch} | total time: {total_training_time/60:.2f}m")
if step % 10 == 0:
wandb_run.log({
"step": step,
"total_training_flops": flops_so_far,
"total_training_time": total_training_time,
"train/loss": debiased_smooth_loss,
"train/lrm": lrm,
"train/dt": dt,
"train/tok_per_sec": tok_per_sec,
"train/mfu": mfu,
"train/epoch": current_epoch,
})
# The garbage collector spends ~500ms scanning for cycles quite frequently.
# We manually manage it to avoid these pauses during training.
if step == 1:
gc.collect() # manually collect a lot of garbage from setup
gc.freeze() # freeze all currently surviving objects and exclude them from GC
gc.disable() # disable GC entirely except:
elif step % 5000 == 0: # every 5000 steps...
gc.collect() # manually collect, just to be safe for very long runs
# print a few more stats
print0(f"Peak memory usage: {get_max_memory() / 1024 / 1024:.2f}MiB")
print0(f"Total training time: {total_training_time/60:.2f}m")
print0(f"Minimum validation bpb: {min_val_bpb:.4f}")
# Log to report
from nanochat.report import get_report
get_report().log(section="SFT", data=[
user_config, # CLI args
{ # stats about the training setup
"Number of iterations": step,
"DDP world size": ddp_world_size,
},
{ # stats about training outcomes
"Minimum validation bpb": min_val_bpb,
}
])
# cleanup
wandb_run.finish() # wandb run finish
compute_cleanup() | --- +++ @@ -1,3 +1,13 @@+"""
+Supervised fine-tuning (SFT) the model.
+Run as:
+
+python -m scripts.chat_sft
+
+Or torchrun for training:
+
+torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- --device-batch-size=16
+"""
import gc
import argparse
@@ -175,6 +185,14 @@ approx_progress = 0.0 # will go from 0 to 1 over the course of the epoch
current_epoch = 1 # track epoch for logging
def sft_data_generator_bos_bestfit(split, buffer_size=100):
+ """
+ BOS-aligned dataloader for SFT with bestfit-pad packing.
+
+ Each row in the batch starts with BOS (beginning of a conversation).
+ Conversations are packed using best-fit algorithm. When no conversation fits,
+ the row is padded (instead of cropping) to ensure no tokens are ever discarded.
+ Padding positions have targets masked with -1 (ignore_index for cross-entropy).
+ """
global last_step, approx_progress, current_epoch
assert split in {"train", "val"}, "split must be 'train' or 'val'"
dataset = train_dataset if split == "train" else val_dataset
@@ -498,4 +516,4 @@
# cleanup
wandb_run.finish() # wandb run finish
-compute_cleanup()+compute_cleanup()
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/chat_sft.py |
Write beginner-friendly docstrings |
from nanochat.tokenizer import get_tokenizer, RustBPETokenizer
from nanochat.dataset import parquets_iter_batched
# Random text I got from a random website this morning
news_text = r"""
(Washington, D.C., July 9, 2025)- Yesterday, Mexico’s National Service of Agro-Alimentary Health, Safety, and Quality (SENASICA) reported a new case of New World Screwworm (NWS) in Ixhuatlan de Madero, Veracruz in Mexico, which is approximately 160 miles northward of the current sterile fly dispersal grid, on the eastern side of the country and 370 miles south of the U.S./Mexico border. This new northward detection comes approximately two months after northern detections were reported in Oaxaca and Veracruz, less than 700 miles away from the U.S. border, which triggered the closure of our ports to Mexican cattle, bison, and horses on May 11, 2025.
While USDA announced a risk-based phased port re-opening strategy for cattle, bison, and equine from Mexico beginning as early as July 7, 2025, this newly reported NWS case raises significant concern about the previously reported information shared by Mexican officials and severely compromises the outlined port reopening schedule of five ports from July 7-September 15. Therefore, in order to protect American livestock and our nation’s food supply, Secretary Rollins has ordered the closure of livestock trade through southern ports of entry effective immediately.
“The United States has promised to be vigilant — and after detecting this new NWS case, we are pausing the planned port reopening’s to further quarantine and target this deadly pest in Mexico. We must see additional progress combatting NWS in Veracruz and other nearby Mexican states in order to reopen livestock ports along the Southern border,” said U.S. Secretary of Agriculture Brooke L. Rollins. “Thanks to the aggressive monitoring by USDA staff in the U.S. and in Mexico, we have been able to take quick and decisive action to respond to the spread of this deadly pest.”
""".strip()
# Random Korean text (to test non-English compression)
korean_text = r"""
정직한 사실 위에, 공정한 시선을 더하다
Herald Korea Times
헤럴드코리아타임즈는 정치, 경제, 사회, 문화 등 한국 사회 전반의 주요 이슈를 심도 있게 다루는 종합 온라인 신문사입니다.
우리는 단순히 뉴스를 전달하는 것이 아니라, 사실(Fact)에 기반한 양측의 시각을 균형 있게 조명하며, 독자 여러분이 스스로 판단할 수 있는 ‘정보의 균형’을 제공합니다.
한국 언론의 오랜 문제로 지적되어 온 정치적 편향, 이념적 왜곡에서 벗어나
오직 정직함과 공정함을 원칙으로 삼는 언론을 지향합니다.
어느 한쪽의 주장만을 확대하거나 감추지 않고,
**모든 쟁점에 대해 ‘무엇이 쟁점인지’, ‘누가 무엇을 주장하는지’, ‘사실은 무엇인지’**를 명확히 전달하는 데 집중합니다.
""".strip()
# Random piece of code
code_text = r"""
class BasicTokenizer(Tokenizer):
def __init__(self):
super().__init__()
def train(self, text, vocab_size, verbose=False):
assert vocab_size >= 256
num_merges = vocab_size - 256
# input text preprocessing
text_bytes = text.encode("utf-8") # raw bytes
ids = list(text_bytes) # list of integers in range 0..255
# iteratively merge the most common pairs to create new tokens
merges = {} # (int, int) -> int
vocab = {idx: bytes([idx]) for idx in range(256)} # int -> bytes
for i in range(num_merges):
# count up the number of times every consecutive pair appears
stats = get_stats(ids)
# find the pair with the highest count
pair = max(stats, key=stats.get)
# mint a new token: assign it the next available id
idx = 256 + i
# replace all occurrences of pair in ids with idx
ids = merge(ids, pair, idx)
# save the merge
merges[pair] = idx
vocab[idx] = vocab[pair[0]] + vocab[pair[1]]
# prints
if verbose:
print(f"merge {i+1}/{num_merges}: {pair} -> {idx} ({vocab[idx]}) had {stats[pair]} occurrences")
""".strip()
math_text = r"""
\documentclass[12pt]{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage[margin=1in]{geometry}
\newtheorem{theorem}{Theorem}
\newtheorem*{remark}{Remark}
\begin{document}
\begin{center}
{\Large A Cute Identity: The Sum of Cubes is a Square}
\end{center}
\begin{theorem}
For every integer $n \ge 1$,
\[
\sum_{k=1}^{n} k^{3} \;=\; \left(\frac{n(n+1)}{2}\right)^{2}.
\]
\end{theorem}
\begin{proof}[Proof 1 (Induction)]
Let $S(n) = \sum_{k=1}^{n} k^3$. For $n=1$, $S(1)=1=(1\cdot 2/2)^2$, so the base case holds.
Assume $S(n)=\big(\tfrac{n(n+1)}{2}\big)^2$ for some $n\ge 1$.
Then
\[
S(n+1)
= S(n) + (n+1)^3
= \left(\frac{n(n+1)}{2}\right)^2 + (n+1)^3.
\]
Factor out $(n+1)^2$:
\[
S(n+1)
= (n+1)^2\left( \frac{n^2}{4} + (n+1) \right)
= (n+1)^2\left( \frac{n^2 + 4n + 4}{4} \right)
= (n+1)^2\left( \frac{(n+2)^2}{4} \right).
\]
Thus
\[
S(n+1)=\left(\frac{(n+1)(n+2)}{2}\right)^2,
\]
which matches the claimed formula with $n$ replaced by $n+1$. By induction, the identity holds for all $n\ge 1$.
\end{proof}
\begin{proof}[Proof 2 (Algebraic telescoping)]
Recall the binomial identity
\[
(k+1)^4 - k^4 = 4k^3 + 6k^2 + 4k + 1.
\]
Summing both sides from $k=0$ to $n$ telescopes:
\[
(n+1)^4 - 0^4
= \sum_{k=0}^{n}\big(4k^3 + 6k^2 + 4k + 1\big)
= 4\sum_{k=1}^{n}k^3 + 6\sum_{k=1}^{n}k^2 + 4\sum_{k=1}^{n}k + (n+1).
\]
Using the standard sums
\[
\sum_{k=1}^{n}k = \frac{n(n+1)}{2}
\quad\text{and}\quad
\sum_{k=1}^{n}k^2 = \frac{n(n+1)(2n+1)}{6},
\]
solve for $\sum_{k=1}^{n}k^3$ to get
\[
\sum_{k=1}^{n}k^3 = \left(\frac{n(n+1)}{2}\right)^2.
\]
\end{proof}
\begin{remark}
Geometrically, the identity says: ``adding up $1^3,2^3,\dots,n^3$ builds a perfect square’’—namely the square of the $n$th triangular number. This is why one sometimes calls it the \emph{sum-of-cubes is a square} phenomenon.
\end{remark}
\end{document}
""".strip()
science_text = r"""
Photosynthesis is a photochemical energy transduction process in which light-harvesting pigment–protein complexes within the thylakoid membranes of oxygenic phototrophs absorb photons and initiate charge separation at the reaction center, driving the linear electron transport chain from water to NADP⁺ via photosystem II, the cytochrome b₆f complex, and photosystem I, concomitantly generating a trans-thylakoid proton motive force utilized by chloroplastic ATP synthase. The light-dependent reactions produce ATP and NADPH, which fuel the Calvin–Benson–Bassham cycle in the stroma, wherein ribulose-1,5-bisphosphate is carboxylated by ribulose-1,5-bisphosphate carboxylase/oxygenase (RuBisCO) to form 3-phosphoglycerate, subsequently reduced and regenerated through a series of enzymatic steps, enabling net assimilation of CO₂ into triose phosphates and ultimately carbohydrates. This process is tightly regulated by photoprotective mechanisms, redox feedback, and metabolite flux, representing a central biochemical pathway coupling solar energy capture to the biosphere’s primary productivity.
""".strip()
# The tokenizer was trained on data from earlier shards, so it has seen this data
train_docs = next(parquets_iter_batched(split="train"))
train_text = "\n".join(train_docs)
val_docs = next(parquets_iter_batched(split="val"))
val_text = "\n".join(val_docs)
all_text = [
("news", news_text),
("korean", korean_text),
("code", code_text),
("math", math_text),
("science", science_text),
("fwe-train", train_text),
]
if val_text:
all_text.append(("fwe-val", val_text))
# Try out current default compared to GPT-2 and GPT-4 tokenizers
tokenizer_results = {}
vocab_sizes = {}
for tokenizer_name in ["gpt2", "gpt4", "ours"]:
if tokenizer_name == "gpt2":
tokenizer = RustBPETokenizer.from_pretrained("gpt2") # gpt-2 base model tokenizer
elif tokenizer_name == "gpt4":
tokenizer = RustBPETokenizer.from_pretrained("cl100k_base") # gpt-4 base model tokenizer
else:
tokenizer = get_tokenizer()
vocab_sizes[tokenizer_name] = tokenizer.get_vocab_size()
tokenizer_results[tokenizer_name] = {}
for name, text in all_text:
encoded = tokenizer.encode(text)
decoded = tokenizer.decode(encoded)
assert decoded == text
encoded_bytes = text.encode('utf-8')
ratio = len(encoded_bytes) / len(encoded)
tokenizer_results[tokenizer_name][name] = {
'bytes': len(encoded_bytes),
'tokens': len(encoded),
'ratio': ratio
}
# ANSI color codes
GREEN = '\033[92m'
RED = '\033[91m'
RESET = '\033[0m'
# Print vocab sizes
print(f"\nVocab sizes:")
print(f"GPT-2: {vocab_sizes['gpt2']}")
print(f"GPT-4: {vocab_sizes['gpt4']}")
print(f"Ours: {vocab_sizes['ours']}")
def print_comparison(baseline_name, baseline_results, ours_results, all_text):
print(f"\nComparison with {baseline_name}:")
print("=" * 95)
print(f"{'Text Type':<10} {'Bytes':<8} {baseline_name:<15} {'Ours':<15} {'Relative':<12} {'Better':<10}")
print(f"{'':10} {'':8} {'Tokens':<7} {'Ratio':<7} {'Tokens':<7} {'Ratio':<7} {'Diff %':<12}")
print("-" * 95)
for name, text in all_text:
baseline_data = baseline_results[name]
ours_data = ours_results[name]
# Calculate relative difference (positive means ours is better, negative means worse)
# Using tokens: fewer tokens is better, so we calculate (baseline_tokens - ours_tokens) / baseline_tokens
relative_diff = ((baseline_data['tokens'] - ours_data['tokens']) / baseline_data['tokens']) * 100
# Determine which has better compression (higher ratio = better)
if baseline_data['ratio'] > ours_data['ratio']:
baseline_color, ours_color = GREEN, RED
better = baseline_name
diff_color = RED
elif ours_data['ratio'] > baseline_data['ratio']:
baseline_color, ours_color = RED, GREEN
better = "Ours"
diff_color = GREEN
else:
baseline_color, ours_color = "", ""
better = "Tie"
diff_color = ""
print(f"{name:<10} {baseline_data['bytes']:<8} "
f"{baseline_color}{baseline_data['tokens']:<7}{RESET} "
f"{baseline_color}{baseline_data['ratio']:<7.2f}{RESET} "
f"{ours_color}{ours_data['tokens']:<7}{RESET} "
f"{ours_color}{ours_data['ratio']:<7.2f}{RESET} "
f"{diff_color}{relative_diff:+7.1f}%{RESET} "
f"{better:<10}")
# Print comparisons
print_comparison("GPT-2", tokenizer_results['gpt2'], tokenizer_results['ours'], all_text)
print_comparison("GPT-4", tokenizer_results['gpt4'], tokenizer_results['ours'], all_text)
# Log to report
from nanochat.report import get_report
lines = []
for baseline_name in ["GPT-2", "GPT-4"]:
baseline_key = baseline_name.lower().replace('-', '')
baseline_results = tokenizer_results[baseline_key]
ours_results = tokenizer_results['ours']
lines.append(f"### Comparison with {baseline_name}")
lines.append("")
lines.append("| Text Type | Bytes | " + baseline_name + " Tokens | " + baseline_name + " Ratio | Ours Tokens | Ours Ratio | Relative Diff % |")
lines.append("|-----------|-------|--------------|--------------|-------------|------------|-----------------|")
for name, text in all_text:
baseline_data = baseline_results[name]
ours_data = ours_results[name]
relative_diff = ((baseline_data['tokens'] - ours_data['tokens']) / baseline_data['tokens']) * 100
lines.append(f"| {name} | {baseline_data['bytes']} | {baseline_data['tokens']} | {baseline_data['ratio']:.2f} | {ours_data['tokens']} | {ours_data['ratio']:.2f} | {relative_diff:+.1f}% |")
lines.append("")
report_markdown = "\n".join(lines)
get_report().log(section="Tokenizer evaluation", data=[
report_markdown,
]) | --- +++ @@ -1,3 +1,6 @@+"""
+Evaluate compression ratio of the tokenizer.
+"""
from nanochat.tokenizer import get_tokenizer, RustBPETokenizer
from nanochat.dataset import parquets_iter_batched
@@ -198,6 +201,7 @@ print(f"Ours: {vocab_sizes['ours']}")
def print_comparison(baseline_name, baseline_results, ours_results, all_text):
+ """Print comparison table between baseline tokenizer and ours."""
print(f"\nComparison with {baseline_name}:")
print("=" * 95)
print(f"{'Text Type':<10} {'Bytes':<8} {baseline_name:<15} {'Ours':<15} {'Relative':<12} {'Better':<10}")
@@ -258,4 +262,4 @@ report_markdown = "\n".join(lines)
get_report().log(section="Tokenizer evaluation", data=[
report_markdown,
-])+])
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/tok_eval.py |
Document my Python code with docstrings | import os
import time
import argparse
import torch
from nanochat.tokenizer import RustBPETokenizer
from nanochat.common import get_base_dir
from nanochat.dataset import parquets_iter_batched
# -----------------------------------------------------------------------------
# Parse command line arguments
parser = argparse.ArgumentParser(description='Train a BPE tokenizer')
parser.add_argument('--max-chars', type=int, default=2_000_000_000, help='Maximum characters to train on (default: 10B)')
parser.add_argument('--doc-cap', type=int, default=10_000, help='Maximum characters per document (default: 10,000)')
parser.add_argument('--vocab-size', type=int, default=32768, help='Vocabulary size (default: 32768 = 2^15)')
args = parser.parse_args()
print(f"max_chars: {args.max_chars:,}")
print(f"doc_cap: {args.doc_cap:,}")
print(f"vocab_size: {args.vocab_size:,}")
# -----------------------------------------------------------------------------
# Text iterator
def text_iterator():
nchars = 0
for batch in parquets_iter_batched(split="train"):
for doc in batch:
doc_text = doc
if len(doc_text) > args.doc_cap:
doc_text = doc_text[:args.doc_cap]
nchars += len(doc_text)
yield doc_text
if nchars > args.max_chars:
return
text_iter = text_iterator()
# -----------------------------------------------------------------------------
# Train the tokenizer
t0 = time.time()
tokenizer = RustBPETokenizer.train_from_iterator(text_iter, args.vocab_size)
t1 = time.time()
train_time = t1 - t0
print(f"Training time: {train_time:.2f}s")
# -----------------------------------------------------------------------------
# Save the tokenizer to disk
base_dir = get_base_dir()
tokenizer_dir = os.path.join(base_dir, "tokenizer")
tokenizer.save(tokenizer_dir)
# -----------------------------------------------------------------------------
# Quick inline sanity check
test_text = """Hello world! This is a test.
Numbers: 123, 4567, 89
Contractions: I'm, you're, it's
Special chars: @#$%^&*()
Unicode: 你好世界 🌍"""
encoded = tokenizer.encode(test_text)
decoded = tokenizer.decode(encoded)
assert decoded == test_text
# -----------------------------------------------------------------------------
# One more thing: we wish to cache a mapping from token id to number of bytes of that token
# for efficient evaluation of bits per byte. Unlike the typical mean loss, this
# allows us to report a loss that is invariant to the vocab size of the tokenizer.
# The bits per byte on the validation set is then one of the primary metrics we care about.
vocab_size = tokenizer.get_vocab_size()
special_set = set(tokenizer.get_special_tokens())
token_strings = [tokenizer.decode([token_id]) for token_id in range(vocab_size)]
token_bytes = []
for token_id in range(vocab_size):
token_str = token_strings[token_id] # the Python string representation of this token
if token_str in special_set:
token_bytes.append(0) # special characters are not counted
else:
id_bytes = len(token_str.encode("utf-8")) # number of bytes that make up this token
token_bytes.append(id_bytes)
token_bytes = torch.tensor(token_bytes, dtype=torch.int32, device='cpu')
token_bytes_path = os.path.join(tokenizer_dir, "token_bytes.pt")
with open(token_bytes_path, "wb") as f:
torch.save(token_bytes, f)
print(f"Saved token_bytes to {token_bytes_path}")
# Log to report
from nanochat.report import get_report
token_bytes_nonzero = (token_bytes[token_bytes > 0]).to(dtype=torch.float32)
get_report().log(section="Tokenizer training", data=[
vars(args), # argparse command line arguments
{"train_time": train_time},
{"num_special_tokens": len(special_set)},
{
"token_bytes_min": int(token_bytes_nonzero.min().item()),
"token_bytes_max": int(token_bytes_nonzero.max().item()),
"token_bytes_mean": token_bytes_nonzero.mean().item(),
"token_bytes_std": token_bytes_nonzero.std().item(),
}
]) | --- +++ @@ -1,3 +1,7 @@+"""
+Train a tokenizer using our own BPE Tokenizer library.
+In the style of GPT-4 tokenizer.
+"""
import os
import time
import argparse
@@ -22,6 +26,11 @@ # Text iterator
def text_iterator():
+ """
+ 1) Flatten the batches into a single iterator
+ 2) Crop every document to args.doc_cap characters
+ 3) Break when we've seen args.max_chars characters
+ """
nchars = 0
for batch in parquets_iter_batched(split="train"):
for doc in batch:
@@ -94,4 +103,4 @@ "token_bytes_mean": token_bytes_nonzero.mean().item(),
"token_bytes_std": token_bytes_nonzero.std().item(),
}
-])+])
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/scripts/tok_train.py |
Turn comments into proper docstrings |
import os
import json
from tasks.common import Task
class CustomJSON(Task):
def __init__(self, filepath, **kwargs):
super().__init__(**kwargs)
self.filepath = filepath
self.conversations = []
# Load all conversations from the JSONL file
if not os.path.exists(filepath):
# Helpful error message due to recent change. Will be removed in the future.
print("-" * 80)
print(f"Warning: File {filepath} does not exist")
print("HINT (Oct 21 2025)")
print("If you recently did a git pull and suddenly see this, it might be due to the new addition of identity conversations")
print("See this discussion for more details: https://github.com/karpathy/nanochat/discussions/139")
print("Quick fix: simply run the following command to download the file and you're done:")
print(f"curl -L -o {filepath} https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl")
print("-" * 80)
else:
with open(filepath, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if not line: # skip empty lines
continue
messages = json.loads(line)
# Validate the conversation structure
assert isinstance(messages, list), f"Expected list of messages, got {type(messages)}"
assert len(messages) >= 2, f"Conversation must have at least 2 messages, got {len(messages)}"
# Validate message structure and alternating roles
for i, message in enumerate(messages):
assert "role" in message, f"Message {i} missing 'role' field"
assert "content" in message, f"Message {i} missing 'content' field"
expected_role = "user" if i % 2 == 0 else "assistant"
assert message["role"] == expected_role, f"Message {i} has role {message['role']} but should be {expected_role}"
assert isinstance(message["content"], str), f"Message {i} content must be a string"
self.conversations.append(messages)
self.length = len(self.conversations)
def num_examples(self):
return self.length
def get_example(self, index):
messages = self.conversations[index]
conversation = {
"messages": messages,
}
return conversation
| --- +++ @@ -1,9 +1,18 @@+"""
+CustomJSON task for loading conversations from JSONL files.
+Each line in the JSONL file should be a JSON array of messages.
+"""
import os
import json
from tasks.common import Task
class CustomJSON(Task):
+ """
+ Load conversations from a JSONL file.
+ Each line should be a JSON array of message objects with 'role' and 'content' fields.
+ Example line: [{"role":"user","content":"Hi"},{"role":"assistant","content":"Hello"}]
+ """
def __init__(self, filepath, **kwargs):
super().__init__(**kwargs)
@@ -53,3 +62,4 @@ "messages": messages,
}
return conversation
+
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/customjson.py |
Add professional docstrings to my codebase | from fastapi import APIRouter, HTTPException, Depends, Query
from sqlalchemy.orm import Session
from typing import List, Optional
from app.backend.database import get_db
from app.backend.repositories.flow_run_repository import FlowRunRepository
from app.backend.repositories.flow_repository import FlowRepository
from app.backend.models.schemas import (
FlowRunCreateRequest,
FlowRunUpdateRequest,
FlowRunResponse,
FlowRunSummaryResponse,
FlowRunStatus,
ErrorResponse
)
router = APIRouter(prefix="/flows/{flow_id}/runs", tags=["flow-runs"])
@router.post(
"/",
response_model=FlowRunResponse,
responses={
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def create_flow_run(
flow_id: int,
request: FlowRunCreateRequest,
db: Session = Depends(get_db)
):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Create the flow run
run_repo = FlowRunRepository(db)
flow_run = run_repo.create_flow_run(
flow_id=flow_id,
request_data=request.request_data
)
return FlowRunResponse.from_orm(flow_run)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to create flow run: {str(e)}")
@router.get(
"/",
response_model=List[FlowRunSummaryResponse],
responses={
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_flow_runs(
flow_id: int,
limit: int = Query(50, ge=1, le=100, description="Maximum number of runs to return"),
offset: int = Query(0, ge=0, description="Number of runs to skip"),
db: Session = Depends(get_db)
):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Get flow runs
run_repo = FlowRunRepository(db)
flow_runs = run_repo.get_flow_runs_by_flow_id(flow_id, limit=limit, offset=offset)
return [FlowRunSummaryResponse.from_orm(run) for run in flow_runs]
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve flow runs: {str(e)}")
@router.get(
"/active",
response_model=Optional[FlowRunResponse],
responses={
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_active_flow_run(flow_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Get active flow run
run_repo = FlowRunRepository(db)
active_run = run_repo.get_active_flow_run(flow_id)
return FlowRunResponse.from_orm(active_run) if active_run else None
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve active flow run: {str(e)}")
@router.get(
"/latest",
response_model=Optional[FlowRunResponse],
responses={
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_latest_flow_run(flow_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Get latest flow run
run_repo = FlowRunRepository(db)
latest_run = run_repo.get_latest_flow_run(flow_id)
return FlowRunResponse.from_orm(latest_run) if latest_run else None
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve latest flow run: {str(e)}")
@router.get(
"/{run_id}",
response_model=FlowRunResponse,
responses={
404: {"model": ErrorResponse, "description": "Flow or run not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_flow_run(flow_id: int, run_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Get flow run
run_repo = FlowRunRepository(db)
flow_run = run_repo.get_flow_run_by_id(run_id)
if not flow_run or flow_run.flow_id != flow_id:
raise HTTPException(status_code=404, detail="Flow run not found")
return FlowRunResponse.from_orm(flow_run)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve flow run: {str(e)}")
@router.put(
"/{run_id}",
response_model=FlowRunResponse,
responses={
404: {"model": ErrorResponse, "description": "Flow or run not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def update_flow_run(
flow_id: int,
run_id: int,
request: FlowRunUpdateRequest,
db: Session = Depends(get_db)
):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Update flow run
run_repo = FlowRunRepository(db)
# First verify the run exists and belongs to this flow
existing_run = run_repo.get_flow_run_by_id(run_id)
if not existing_run or existing_run.flow_id != flow_id:
raise HTTPException(status_code=404, detail="Flow run not found")
flow_run = run_repo.update_flow_run(
run_id=run_id,
status=request.status,
results=request.results,
error_message=request.error_message
)
if not flow_run:
raise HTTPException(status_code=404, detail="Flow run not found")
return FlowRunResponse.from_orm(flow_run)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to update flow run: {str(e)}")
@router.delete(
"/{run_id}",
responses={
204: {"description": "Flow run deleted successfully"},
404: {"model": ErrorResponse, "description": "Flow or run not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def delete_flow_run(flow_id: int, run_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Verify run exists and belongs to this flow
run_repo = FlowRunRepository(db)
existing_run = run_repo.get_flow_run_by_id(run_id)
if not existing_run or existing_run.flow_id != flow_id:
raise HTTPException(status_code=404, detail="Flow run not found")
success = run_repo.delete_flow_run(run_id)
if not success:
raise HTTPException(status_code=404, detail="Flow run not found")
return {"message": "Flow run deleted successfully"}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to delete flow run: {str(e)}")
@router.delete(
"/",
responses={
204: {"description": "All flow runs deleted successfully"},
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def delete_all_flow_runs(flow_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Delete all flow runs
run_repo = FlowRunRepository(db)
deleted_count = run_repo.delete_flow_runs_by_flow_id(flow_id)
return {"message": f"Deleted {deleted_count} flow runs successfully"}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to delete flow runs: {str(e)}")
@router.get(
"/count",
responses={
200: {"description": "Flow run count"},
404: {"model": ErrorResponse, "description": "Flow not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_flow_run_count(flow_id: int, db: Session = Depends(get_db)):
try:
# Verify flow exists
flow_repo = FlowRepository(db)
flow = flow_repo.get_flow_by_id(flow_id)
if not flow:
raise HTTPException(status_code=404, detail="Flow not found")
# Get run count
run_repo = FlowRunRepository(db)
count = run_repo.get_flow_run_count(flow_id)
return {"flow_id": flow_id, "total_runs": count}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to get flow run count: {str(e)}") | --- +++ @@ -30,6 +30,7 @@ request: FlowRunCreateRequest,
db: Session = Depends(get_db)
):
+ """Create a new flow run for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -64,6 +65,7 @@ offset: int = Query(0, ge=0, description="Number of runs to skip"),
db: Session = Depends(get_db)
):
+ """Get all runs for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -90,6 +92,7 @@ },
)
async def get_active_flow_run(flow_id: int, db: Session = Depends(get_db)):
+ """Get the current active (IN_PROGRESS) run for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -116,6 +119,7 @@ },
)
async def get_latest_flow_run(flow_id: int, db: Session = Depends(get_db)):
+ """Get the most recent run for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -142,6 +146,7 @@ },
)
async def get_flow_run(flow_id: int, run_id: int, db: Session = Depends(get_db)):
+ """Get a specific flow run by ID"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -176,6 +181,7 @@ request: FlowRunUpdateRequest,
db: Session = Depends(get_db)
):
+ """Update an existing flow run"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -216,6 +222,7 @@ },
)
async def delete_flow_run(flow_id: int, run_id: int, db: Session = Depends(get_db)):
+ """Delete a flow run"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -249,6 +256,7 @@ },
)
async def delete_all_flow_runs(flow_id: int, db: Session = Depends(get_db)):
+ """Delete all runs for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
@@ -276,6 +284,7 @@ },
)
async def get_flow_run_count(flow_id: int, db: Session = Depends(get_db)):
+ """Get the total count of runs for the specified flow"""
try:
# Verify flow exists
flow_repo = FlowRepository(db)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/routes/flow_runs.py |
Generate docstrings for script automation |
import random
class Task:
def __init__(self, start=0, stop=None, step=1):
# allows a lightweight logical view over a dataset
assert start >= 0, f"Start must be non-negative, got {start}"
assert stop is None or stop >= start, f"Stop should be greater than or equal to start, got {stop} and {start}"
assert step >= 1, f"Step must be strictly positive, got {step}"
self.start = start
self.stop = stop # could be None here
self.step = step
@property
def eval_type(self):
# one of 'generative' | 'categorical'
raise NotImplementedError
def num_examples(self):
raise NotImplementedError
def get_example(self, index):
raise NotImplementedError
def __len__(self):
start = self.start
stop = self.num_examples() if self.stop is None else self.stop
step = self.step
span = stop - start
num = (span + step - 1) // step # ceil_div(span, step)
assert num >= 0, f"Negative number of examples???: {num}" # prevent footguns
return num
def __getitem__(self, index: int):
assert isinstance(index, int), f"Index must be an integer, got {type(index)}"
physical_index = self.start + index * self.step
conversation = self.get_example(physical_index)
return conversation
def evaluate(self, problem, completion):
raise NotImplementedError
class TaskMixture(Task):
def __init__(self, tasks, **kwargs):
super().__init__(**kwargs)
# tasks is a list of Task objects
self.tasks = tasks
self.lengths = [len(task) for task in self.tasks]
self.num_conversations = sum(self.lengths)
# Build list of all (task_idx, local_idx) pairs
self.index_map = []
for task_idx, task_length in enumerate(self.lengths):
for local_idx in range(task_length):
self.index_map.append((task_idx, local_idx))
# Deterministically shuffle to mix tasks throughout training
rng = random.Random(42)
rng.shuffle(self.index_map)
# Note: this is not the most elegant or best solution, but it's ok for now
def num_examples(self):
return self.num_conversations
def get_example(self, index):
assert 0 <= index < self.num_conversations, f"Index {index} out of range for mixture with {self.num_conversations} conversations"
task_idx, local_idx = self.index_map[index]
return self.tasks[task_idx][local_idx]
class TaskSequence(Task):
def __init__(self, tasks, **kwargs):
super().__init__(**kwargs)
self.tasks = tasks
self.lengths = [len(task) for task in self.tasks]
self.num_conversations = sum(self.lengths)
def num_examples(self):
return self.num_conversations
def get_example(self, index):
assert 0 <= index < self.num_conversations, f"Index {index} out of range for sequence with {self.num_conversations} conversations"
for task_idx, task_length in enumerate(self.lengths):
if index < task_length:
return self.tasks[task_idx][index]
index -= task_length
def render_mc(question, letters, choices):
query = f"Multiple Choice question: {question}\n"
query += "".join([f"- {choice}={letter}\n" for letter, choice in zip(letters, choices)])
query += "\nRespond only with the letter of the correct answer."
return query
if __name__ == "__main__":
# very lightweight test of slicing
from tasks.mmlu import MMLU
ds = MMLU(subset="auxiliary_train", split="train")
print("Length of MMLU: ", len(ds))
ex = ds[5]
print("5th example: ", ex)
ds = MMLU(subset="auxiliary_train", split="train", start=5, stop=10)
print("Length of sliced MMLU[5:10]: ", len(ds))
print("0th example of sliced MMLU: ", ds[0])
print("They match: ", ex == ds[0]) | --- +++ @@ -1,7 +1,16 @@+"""
+Base class for all Tasks.
+A Task is basically a dataset of conversations, together with some
+metadata and often also evaluation criteria.
+Example tasks: MMLU, ARC-Easy, ARC-Challenge, GSM8K, HumanEval, SmolTalk.
+"""
import random
class Task:
+ """
+ Base class of a Task. Allows for lightweight slicing of the underlying dataset.
+ """
def __init__(self, start=0, stop=None, step=1):
# allows a lightweight logical view over a dataset
@@ -43,6 +52,10 @@
class TaskMixture(Task):
+ """
+ For SFT Training it becomes useful to train on a mixture of datasets.
+ Fun trick: if you wish to oversample any task, just pass it in multiple times in the list.
+ """
def __init__(self, tasks, **kwargs):
super().__init__(**kwargs)
@@ -64,12 +77,20 @@ return self.num_conversations
def get_example(self, index):
+ """
+ Access conversations according to a deterministic shuffle of all examples.
+ This ensures tasks are mixed throughout training, regardless of dataset size.
+ """
assert 0 <= index < self.num_conversations, f"Index {index} out of range for mixture with {self.num_conversations} conversations"
task_idx, local_idx = self.index_map[index]
return self.tasks[task_idx][local_idx]
class TaskSequence(Task):
+ """
+ For SFT Training sometimes we want to sequentially train on a list of tasks.
+ This is useful for cases that require a training curriculum.
+ """
def __init__(self, tasks, **kwargs):
super().__init__(**kwargs)
@@ -89,6 +110,21 @@
def render_mc(question, letters, choices):
+ """
+ The common multiple choice rendering format we will use.
+
+ Note two important design decisions:
+ 1)
+ Bigger models don't care as much, but smaller models prefer to have
+ the letter *after* the choice, which results in better binding.
+ 2)
+ There is no whitespace between the delimiter (=) and the letter.
+ This is actually critical because the tokenizer has different token ids
+ for " A" vs. "A". The assistant responses will be just the letter itself,
+ i.e. "A", so it is important that here in the prompt it is the exact same
+ token, i.e. "A" with no whitespace before it. Again, bigger models don't care
+ about this too much, but smaller models do care about some of these details.
+ """
query = f"Multiple Choice question: {question}\n"
query += "".join([f"- {choice}={letter}\n" for letter, choice in zip(letters, choices)])
query += "\nRespond only with the letter of the correct answer."
@@ -108,4 +144,4 @@ print("Length of sliced MMLU[5:10]: ", len(ds))
print("0th example of sliced MMLU: ", ds[0])
- print("They match: ", ex == ds[0])+ print("They match: ", ex == ds[0])
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/common.py |
Document functions with clear intent | from fastapi import APIRouter, HTTPException, Request, Depends
from fastapi.responses import StreamingResponse
from sqlalchemy.orm import Session
import asyncio
from app.backend.database import get_db
from app.backend.models.schemas import ErrorResponse, HedgeFundRequest, BacktestRequest, BacktestDayResult, BacktestPerformanceMetrics
from app.backend.models.events import StartEvent, ProgressUpdateEvent, ErrorEvent, CompleteEvent
from app.backend.services.graph import create_graph, parse_hedge_fund_response, run_graph_async
from app.backend.services.portfolio import create_portfolio
from app.backend.services.backtest_service import BacktestService
from app.backend.services.api_key_service import ApiKeyService
from src.utils.progress import progress
from src.utils.analysts import get_agents_list
router = APIRouter(prefix="/hedge-fund")
@router.post(
path="/run",
responses={
200: {"description": "Successful response with streaming updates"},
400: {"model": ErrorResponse, "description": "Invalid request parameters"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def run(request_data: HedgeFundRequest, request: Request, db: Session = Depends(get_db)):
try:
# Hydrate API keys from database if not provided
if not request_data.api_keys:
api_key_service = ApiKeyService(db)
request_data.api_keys = api_key_service.get_api_keys_dict()
# Create the portfolio
portfolio = create_portfolio(request_data.initial_cash, request_data.margin_requirement, request_data.tickers, request_data.portfolio_positions)
# Construct agent graph using the React Flow graph structure
graph = create_graph(
graph_nodes=request_data.graph_nodes,
graph_edges=request_data.graph_edges
)
graph = graph.compile()
# Log a test progress update for debugging
progress.update_status("system", None, "Preparing hedge fund run")
# Convert model_provider to string if it's an enum
model_provider = request_data.model_provider
if hasattr(model_provider, "value"):
model_provider = model_provider.value
# Function to detect client disconnection
async def wait_for_disconnect():
try:
while True:
message = await request.receive()
if message["type"] == "http.disconnect":
return True
except Exception:
return True
# Set up streaming response
async def event_generator():
# Queue for progress updates
progress_queue = asyncio.Queue()
run_task = None
disconnect_task = None
# Simple handler to add updates to the queue
def progress_handler(agent_name, ticker, status, analysis, timestamp):
event = ProgressUpdateEvent(agent=agent_name, ticker=ticker, status=status, timestamp=timestamp, analysis=analysis)
progress_queue.put_nowait(event)
# Register our handler with the progress tracker
progress.register_handler(progress_handler)
try:
# Start the graph execution in a background task
run_task = asyncio.create_task(
run_graph_async(
graph=graph,
portfolio=portfolio,
tickers=request_data.tickers,
start_date=request_data.start_date,
end_date=request_data.end_date,
model_name=request_data.model_name,
model_provider=model_provider,
request=request_data, # Pass the full request for agent-specific model access
)
)
# Start the disconnect detection task
disconnect_task = asyncio.create_task(wait_for_disconnect())
# Send initial message
yield StartEvent().to_sse()
# Stream progress updates until run_task completes or client disconnects
while not run_task.done():
# Check if client disconnected
if disconnect_task.done():
print("Client disconnected, cancelling hedge fund execution")
run_task.cancel()
try:
await run_task
except asyncio.CancelledError:
pass
return
# Either get a progress update or wait a bit
try:
event = await asyncio.wait_for(progress_queue.get(), timeout=1.0)
yield event.to_sse()
except asyncio.TimeoutError:
# Just continue the loop
pass
# Get the final result
try:
result = await run_task
except asyncio.CancelledError:
print("Task was cancelled")
return
if not result or not result.get("messages"):
yield ErrorEvent(message="Failed to generate hedge fund decisions").to_sse()
return
# Send the final result
final_data = CompleteEvent(
data={
"decisions": parse_hedge_fund_response(result.get("messages", [])[-1].content),
"analyst_signals": result.get("data", {}).get("analyst_signals", {}),
"current_prices": result.get("data", {}).get("current_prices", {}),
}
)
yield final_data.to_sse()
except asyncio.CancelledError:
print("Event generator cancelled")
return
finally:
# Clean up
progress.unregister_handler(progress_handler)
if run_task and not run_task.done():
run_task.cancel()
try:
await run_task
except asyncio.CancelledError:
pass
if disconnect_task and not disconnect_task.done():
disconnect_task.cancel()
# Return a streaming response
return StreamingResponse(event_generator(), media_type="text/event-stream")
except HTTPException as e:
raise e
except Exception as e:
raise HTTPException(status_code=500, detail=f"An error occurred while processing the request: {str(e)}")
@router.post(
path="/backtest",
responses={
200: {"description": "Successful response with streaming backtest updates"},
400: {"model": ErrorResponse, "description": "Invalid request parameters"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def backtest(request_data: BacktestRequest, request: Request, db: Session = Depends(get_db)):
try:
# Hydrate API keys from database if not provided
if not request_data.api_keys:
api_key_service = ApiKeyService(db)
request_data.api_keys = api_key_service.get_api_keys_dict()
# Convert model_provider to string if it's an enum
model_provider = request_data.model_provider
if hasattr(model_provider, "value"):
model_provider = model_provider.value
# Create the portfolio (same as /run endpoint)
portfolio = create_portfolio(
request_data.initial_capital,
request_data.margin_requirement,
request_data.tickers,
request_data.portfolio_positions
)
# Construct agent graph using the React Flow graph structure (same as /run endpoint)
graph = create_graph(graph_nodes=request_data.graph_nodes, graph_edges=request_data.graph_edges)
graph = graph.compile()
# Create backtest service with the compiled graph
backtest_service = BacktestService(
graph=graph,
portfolio=portfolio,
tickers=request_data.tickers,
start_date=request_data.start_date,
end_date=request_data.end_date,
initial_capital=request_data.initial_capital,
model_name=request_data.model_name,
model_provider=model_provider,
request=request_data, # Pass the full request for agent-specific model access
)
# Function to detect client disconnection
async def wait_for_disconnect():
try:
while True:
message = await request.receive()
if message["type"] == "http.disconnect":
return True
except Exception:
return True
# Set up streaming response
async def event_generator():
progress_queue = asyncio.Queue()
backtest_task = None
disconnect_task = None
# Global progress handler to capture individual agent updates during backtest
def progress_handler(agent_name, ticker, status, analysis, timestamp):
event = ProgressUpdateEvent(agent=agent_name, ticker=ticker, status=status, timestamp=timestamp, analysis=analysis)
progress_queue.put_nowait(event)
# Progress callback to handle backtest-specific updates
def progress_callback(update):
if update["type"] == "progress":
event = ProgressUpdateEvent(
agent="backtest",
ticker=None,
status=f"Processing {update['current_date']} ({update['current_step']}/{update['total_dates']})",
timestamp=None,
analysis=None
)
progress_queue.put_nowait(event)
elif update["type"] == "backtest_result":
# Convert day result to a streaming event
backtest_result = BacktestDayResult(**update["data"])
# Send the full day result data as JSON in the analysis field
import json
analysis_data = json.dumps(update["data"])
event = ProgressUpdateEvent(
agent="backtest",
ticker=None,
status=f"Completed {backtest_result.date} - Portfolio: ${backtest_result.portfolio_value:,.2f}",
timestamp=None,
analysis=analysis_data
)
progress_queue.put_nowait(event)
# Register our handler with the progress tracker to capture agent updates
progress.register_handler(progress_handler)
try:
# Start the backtest in a background task
backtest_task = asyncio.create_task(
backtest_service.run_backtest_async(progress_callback=progress_callback)
)
# Start the disconnect detection task
disconnect_task = asyncio.create_task(wait_for_disconnect())
# Send initial message
yield StartEvent().to_sse()
# Stream progress updates until backtest_task completes or client disconnects
while not backtest_task.done():
# Check if client disconnected
if disconnect_task.done():
print("Client disconnected, cancelling backtest execution")
backtest_task.cancel()
try:
await backtest_task
except asyncio.CancelledError:
pass
return
# Either get a progress update or wait a bit
try:
event = await asyncio.wait_for(progress_queue.get(), timeout=1.0)
yield event.to_sse()
except asyncio.TimeoutError:
# Just continue the loop
pass
# Get the final result
try:
result = await backtest_task
except asyncio.CancelledError:
print("Backtest task was cancelled")
return
if not result:
yield ErrorEvent(message="Failed to complete backtest").to_sse()
return
# Send the final result
performance_metrics = BacktestPerformanceMetrics(**result["performance_metrics"])
final_data = CompleteEvent(
data={
"performance_metrics": performance_metrics.model_dump(),
"final_portfolio": result["final_portfolio"],
"total_days": len(result["results"]),
}
)
yield final_data.to_sse()
except asyncio.CancelledError:
print("Backtest event generator cancelled")
return
finally:
# Clean up
progress.unregister_handler(progress_handler)
if backtest_task and not backtest_task.done():
backtest_task.cancel()
try:
await backtest_task
except asyncio.CancelledError:
pass
if disconnect_task and not disconnect_task.done():
disconnect_task.cancel()
# Return a streaming response
return StreamingResponse(event_generator(), media_type="text/event-stream")
except HTTPException as e:
raise e
except Exception as e:
raise HTTPException(status_code=500, detail=f"An error occurred while processing the backtest request: {str(e)}")
@router.get(
path="/agents",
responses={
200: {"description": "List of available agents"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_agents():
try:
return {"agents": get_agents_list()}
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve agents: {str(e)}")
| --- +++ @@ -50,6 +50,7 @@
# Function to detect client disconnection
async def wait_for_disconnect():
+ """Wait for client disconnect and return True when it happens"""
try:
while True:
message = await request.receive()
@@ -167,6 +168,7 @@ },
)
async def backtest(request_data: BacktestRequest, request: Request, db: Session = Depends(get_db)):
+ """Run a continuous backtest over a time period with streaming updates."""
try:
# Hydrate API keys from database if not provided
if not request_data.api_keys:
@@ -205,6 +207,7 @@
# Function to detect client disconnection
async def wait_for_disconnect():
+ """Wait for client disconnect and return True when it happens"""
try:
while True:
message = await request.receive()
@@ -341,7 +344,9 @@ },
)
async def get_agents():
+ """Get the list of available agents."""
try:
return {"agents": get_agents_list()}
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve agents: {str(e)}")
+
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/routes/hedge_fund.py |
Provide docstrings following PEP 257 |
from datasets import load_dataset
from tasks.common import Task
class SmolTalk(Task):
def __init__(self, split, **kwargs):
super().__init__(**kwargs)
assert split in ["train", "test"], "SmolTalk split must be train|test"
self.ds = load_dataset("HuggingFaceTB/smol-smoltalk", split=split).shuffle(seed=42)
self.length = len(self.ds)
def num_examples(self):
return self.length
def get_example(self, index):
row = self.ds[index]
messages = row["messages"]
# ---------------------------------------------------------------------
# sanity checking asserts here
# TODO: we could remove these asserts later, for now just don't want any footguns
# there is an optional system message at the beginning
assert len(messages) >= 1
first_message = messages[0]
if first_message["role"] == "system":
rest_messages = messages[1:] # optional system message is OK
else:
rest_messages = messages
assert len(rest_messages) >= 2, "SmolTalk messages must have at least 2 messages"
for i, message in enumerate(rest_messages):
# user and assistant alternate as user,assistant,user,assistant,...
expected_role = "user" if i % 2 == 0 else "assistant"
assert message["role"] == expected_role, f"Message {i} has role {message['role']} but should be {expected_role}"
assert isinstance(message["content"], str), "Content must be a string"
# ---------------------------------------------------------------------
# create and return the Conversation object (ok to emit the system message too)
conversation = {
"messages": messages,
}
return conversation | --- +++ @@ -1,8 +1,14 @@+"""
+SmolTalk by HuggingFace. Good "general" conversational dataset.
+https://huggingface.co/datasets/HuggingFaceTB/smol-smoltalk
+We use the "smol" version, which is more appropriate for smaller models.
+"""
from datasets import load_dataset
from tasks.common import Task
class SmolTalk(Task):
+ """ smol-smoltalk dataset. train is 460K rows, test is 24K rows. """
def __init__(self, split, **kwargs):
super().__init__(**kwargs)
@@ -37,4 +43,4 @@ conversation = {
"messages": messages,
}
- return conversation+ return conversation
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/smoltalk.py |
Write beginner-friendly docstrings |
import re
import random
from tasks.common import Task
from nanochat.common import download_file_with_lock
# Letters of the alphabet
LETTERS = "abcdefghijklmnopqrstuvwxyz"
# A list of 370K English words of large variety
WORD_LIST_URL = "https://raw.githubusercontent.com/dwyl/english-words/refs/heads/master/words_alpha.txt"
# A number bigger than 370K to separate train and test random seeds
TEST_RANDOM_SEED_OFFSET = 10_000_000
# Identical to gsm8k's answer extraction
ANSWER_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract_answer(completion):
match = ANSWER_RE.search(completion)
if match:
match_str = match.group(1).strip()
match_str = match_str.replace(",", "")
return match_str
return None
# User message templates for data augmentation
USER_MSG_TEMPLATES = [
"How many {letter} are in the word {word}",
"How many {letter} are in {word}",
"Count the number of {letter} in {word}",
"How many times does {letter} appear in {word}",
"What's the count of {letter} in {word}",
"In the word {word}, how many {letter} are there",
"How many letter {letter} are in the word {word}",
"Count how many {letter} appear in {word}",
"Tell me the number of {letter} in {word}",
"How many occurrences of {letter} are in {word}",
"Find the count of {letter} in {word}",
"Can you count the {letter} letters in {word}",
"What is the frequency of {letter} in {word}",
"How many {letter}s are in {word}",
"How many {letter}'s are in {word}",
"Count all the {letter} in {word}",
"How many times is {letter} in {word}",
"Number of {letter} in {word}",
"Total count of {letter} in {word}",
"How many {letter} does {word} have",
"How many {letter} does {word} contain",
"What's the number of {letter} in {word}",
"{word} has how many {letter}",
"In {word}, count the {letter}",
"How many {letter} appear in {word}",
"Count the {letter} in {word}",
"Give me the count of {letter} in {word}",
"How many instances of {letter} in {word}",
"Show me how many {letter} are in {word}",
"Calculate the number of {letter} in {word}",
# Spanish
"¿Cuántas {letter} hay en {word}?",
"¿Cuántas veces aparece {letter} en {word}?",
"Cuenta las {letter} en {word}",
"¿Cuántas letras {letter} tiene {word}?",
# Chinese (Simplified)
"{word}中有多少个{letter}",
"{word}里有几个{letter}",
"数一下{word}中的{letter}",
"{word}这个词里有多少{letter}",
# Korean
"{word}에 {letter}가 몇 개 있나요",
"{word}에서 {letter}의 개수는",
"{word}에 {letter}가 몇 번 나오나요",
"{word}라는 단어에 {letter}가 몇 개",
# French
"Combien de {letter} dans {word}",
"Combien de fois {letter} apparaît dans {word}",
"Compte les {letter} dans {word}",
# German
"Wie viele {letter} sind in {word}",
"Wie oft kommt {letter} in {word} vor",
"Zähle die {letter} in {word}",
# Japanese
"{word}に{letter}は何個ありますか",
"{word}の中に{letter}がいくつ",
"{word}に{letter}が何回出てくる",
]
class SpellingBee(Task):
def __init__(self, size=1000, split="train", **kwargs):
super().__init__(**kwargs)
assert split in ["train", "test"], "SpellingBee split must be train|test"
self.size = size
self.split = split
filename = WORD_LIST_URL.split("/")[-1]
word_list_path = download_file_with_lock(WORD_LIST_URL, filename)
with open(word_list_path, 'r', encoding='utf-8') as f:
words = [line.strip() for line in f]
self.words = words
@property
def eval_type(self):
return 'generative'
def num_examples(self):
return self.size
def get_example(self, index):
seed = index if self.split == 'train' else TEST_RANDOM_SEED_OFFSET + index
rng = random.Random(seed)
# pick a random word
word = rng.choice(self.words)
# pick a letter from it (90%) or a random letter (10%)
letter = rng.choice(word) if rng.random() < 0.9 else rng.choice(LETTERS)
# get the correct answer by simply counting
count = word.count(letter)
# create a user message, with a bunch of variations as data augmentation
template = rng.choice(USER_MSG_TEMPLATES)
# 30% chance to lowercase the template (lazy people don't use shift)
if rng.random() < 0.3:
template = template.lower()
quote_options = ['', "'", '"']
letter_quote = rng.choice(quote_options) # is the letter quoted?
word_quote = rng.choice(quote_options) # is the word quoted?
letter_wrapped = f"{letter_quote}{letter}{letter_quote}"
word_wrapped = f"{word_quote}{word}{word_quote}"
user_msg = template.format(letter=letter_wrapped, word=word_wrapped)
if rng.random() < 0.5: # 50% of people don't even use question marks
user_msg += "?"
# Now create the ideal assistant response - build as parts (text + tool calls)
assistant_parts = []
word_letters = ",".join(list(word))
manual_text = f"""We are asked to find the number '{letter}' in the word '{word}'. Let me try a manual approach first.
First spell the word out:
{word}:{word_letters}
Then count the occurrences of '{letter}':
"""
# Little simulated loop of the solution process
# TODO: This is where the fun starts, we could simulate cute little mistakes
# and get the model to review its work and recover from them.
# You might of course hope this could arise in RL too, but realistically you'd want to help it out a bit.
running_count = 0
for i, char in enumerate(word, 1):
if char == letter:
running_count += 1
# note: there deliberately cannot be a space here between i and char
# because this would create a different token! (e.g. " a" and "a" are different tokens)
manual_text += f"{i}:{char} hit! count={running_count}\n"
else:
manual_text += f"{i}:{char}\n"
manual_text += f"\nThis gives us {running_count}."
assistant_parts.append({"type": "text", "text": manual_text})
# Part 2: Python verification
assistant_parts.append({"type": "text", "text": "\n\nLet me double check this using Python:\n\n"})
# Part 3: Python tool call
python_expr = f"'{word}'.count('{letter}')"
assistant_parts.append({"type": "python", "text": python_expr})
# Part 4: Python output
assistant_parts.append({"type": "python_output", "text": str(count)})
# Part 5: Final answer
assistant_parts.append({"type": "text", "text": f"\n\nPython gives us {count}.\n\nMy final answer is:\n\n#### {count}"})
# return the full conversation
messages = [
{"role": "user", "content": user_msg},
{"role": "assistant", "content": assistant_parts}
]
conversation = {
"messages": messages,
}
return conversation
def evaluate(self, conversation, assistant_response):
assert isinstance(assistant_response, str), "Assuming simple string response for now"
# First extract the ground truth answer from the conversation
assistant_message = conversation['messages'][-1]
assert assistant_message['role'] == "assistant", "Last message must be from the Assistant"
assert isinstance(assistant_message['content'], list), "This is expected to be a list of parts"
# The last text part contains the final answer with ####
last_text_part = assistant_message['content'][-1]['text']
# Extract both the ground truth answer and the predicted answer
ref_num = extract_answer(last_text_part)
pred_num = extract_answer(assistant_response)
# Compare and return the success as int
is_correct = int(pred_num == ref_num)
return is_correct
def reward(self, conversation, assistant_response):
is_correct = self.evaluate(conversation, assistant_response)
is_correct_float = float(is_correct)
return is_correct_float
class SimpleSpelling(Task):
def __init__(self, size=1000, split="train", **kwargs):
super().__init__(**kwargs)
assert split in ["train", "test"], "SpellingBee split must be train|test"
self.size = size
self.split = split
filename = WORD_LIST_URL.split("/")[-1]
word_list_path = download_file_with_lock(WORD_LIST_URL, filename)
with open(word_list_path, 'r', encoding='utf-8') as f:
words = [line.strip() for line in f]
rng = random.Random(42)
rng.shuffle(words) # use a different word order than the SpellingBee task
self.words = words
@property
def eval_type(self):
return 'generative'
def num_examples(self):
return self.size
def get_example(self, index):
seed = index if self.split == 'train' else TEST_RANDOM_SEED_OFFSET + index
rng = random.Random(seed)
# pick a random word
word = rng.choice(self.words)
word_letters = ",".join(list(word))
# return the full conversation
messages = [
{"role": "user", "content": f"Spell the word: {word}"},
{"role": "assistant", "content": f"{word}:{word_letters}"}
]
conversation = {
"messages": messages,
}
return conversation
if __name__ == "__main__":
# preview the SpellingBee task, first 10 examples
task = SpellingBee()
for i in range(10):
ex = task.get_example(i)
print("=" * 100)
print(ex['messages'][0]['content'])
print("-" * 100)
# Assistant content is now a list of parts
assistant_parts = ex['messages'][1]['content']
for part in assistant_parts:
if part['type'] == 'text':
print(part['text'], end='')
elif part['type'] == 'python':
print(f"<<{part['text']}=", end='')
elif part['type'] == 'python_output':
print(f"{part['text']}>>", end='')
print()
print("-" * 100)
# # preview the SimpleSpelling task, first 10 examples
# task = SimpleSpelling()
# for i in range(10):
# ex = task.get_example(i)
# print("=" * 100)
# print(ex['messages'][0]['content'])
# print("-" * 100)
# print(ex['messages'][1]['content'])
# # also scrutinize the tokenization (last example only)
# from nanochat.tokenizer import get_tokenizer
# tokenizer = get_tokenizer()
# ids, mask = tokenizer.render_conversation(ex)
# print(tokenizer.visualize_tokenization(ids, mask, with_token_id=True)) | --- +++ @@ -1,3 +1,30 @@+"""
+Task intended to make nanochat better in spelling and counting, for example:
+
+"How many r are in strawberry?" -> 3
+
+An interesting part of this task is that we will get the assistant to
+solve the problem using a combination of manual counting and Python.
+This is a good problem solving "instinct" to mix into the model and RL
+may further refine it to trust one over the other. If we were extra fancy
+(which we could/should be) we'd add small errors here and there to allow
+the model also learn recoveries. We can do this in future versions.
+
+There are two tasks in this file:
+1. SpellingBee: Counting the number of occurrences of a letter in a word
+2. SimpleSpelling: Simply spelling words
+
+(1) is the goal, but (2) exists as a highly condensed version of the part
+that makes (1) difficult, which is word spelling. This is non-trivial for an
+LLM because it has to learn how every token (a little semantic chunk/atom)
+maps to the sequence of individual characters that make it up. Larger models
+learn this eventually on their own, but if we want this capability to exist
+in smaller models, we have to actively encourage it by over-representing it
+in the training data. SFT is a good place to do this.
+
+To preview a few example conversations, run:
+python -m tasks.spellingbee
+"""
import re
import random
@@ -14,6 +41,9 @@ # Identical to gsm8k's answer extraction
ANSWER_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract_answer(completion):
+ """
+ Extract the numerical answer after #### marker.
+ """
match = ANSWER_RE.search(completion)
if match:
match_str = match.group(1).strip()
@@ -175,6 +205,10 @@ return conversation
def evaluate(self, conversation, assistant_response):
+ """
+ Given (conversation, completion), return evaluation outcome (0 = wrong, 1 = correct)
+ Identical to gsm8k's evaluation.
+ """
assert isinstance(assistant_response, str), "Assuming simple string response for now"
# First extract the ground truth answer from the conversation
assistant_message = conversation['messages'][-1]
@@ -190,12 +224,14 @@ return is_correct
def reward(self, conversation, assistant_response):
+ """ Use simple 0-1 reward just like gsm8k."""
is_correct = self.evaluate(conversation, assistant_response)
is_correct_float = float(is_correct)
return is_correct_float
class SimpleSpelling(Task):
+ """Much simpler task designed to get the model to just practice spelling words."""
def __init__(self, size=1000, split="train", **kwargs):
super().__init__(**kwargs)
@@ -268,4 +304,4 @@ # from nanochat.tokenizer import get_tokenizer
# tokenizer = get_tokenizer()
# ids, mask = tokenizer.render_conversation(ex)
- # print(tokenizer.visualize_tokenization(ids, mask, with_token_id=True))+ # print(tokenizer.visualize_tokenization(ids, mask, with_token_id=True))
| https://raw.githubusercontent.com/karpathy/nanochat/HEAD/tasks/spellingbee.py |
Insert docstrings into my code | from fastapi import APIRouter, HTTPException
from typing import List, Dict, Any
from app.backend.models.schemas import ErrorResponse
from app.backend.services.ollama_service import OllamaService
from src.llm.models import get_models_list
router = APIRouter(prefix="/language-models")
# Initialize Ollama service
ollama_service = OllamaService()
@router.get(
path="/",
responses={
200: {"description": "List of available language models"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_language_models():
try:
# Start with cloud models
models = get_models_list()
# Add available Ollama models (handles all checking internally)
ollama_models = await ollama_service.get_available_models()
models.extend(ollama_models)
return {"models": models}
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve models: {str(e)}")
@router.get(
path="/providers",
responses={
200: {"description": "List of available model providers"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_language_model_providers():
try:
models = get_models_list()
# Group models by provider
providers = {}
for model in models:
provider_name = model["provider"]
if provider_name not in providers:
providers[provider_name] = {
"name": provider_name,
"models": []
}
providers[provider_name]["models"].append({
"display_name": model["display_name"],
"model_name": model["model_name"]
})
return {"providers": list(providers.values())}
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve providers: {str(e)}") | --- +++ @@ -18,6 +18,7 @@ },
)
async def get_language_models():
+ """Get the list of available cloud-based and Ollama language models."""
try:
# Start with cloud models
models = get_models_list()
@@ -38,6 +39,7 @@ },
)
async def get_language_model_providers():
+ """Get the list of available model providers with their models grouped."""
try:
models = get_models_list()
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/routes/language_models.py |
Create docstrings for API functions | from sqlalchemy import Column, Integer, String, DateTime, Text, Boolean, JSON, ForeignKey
from sqlalchemy.sql import func
from .connection import Base
class HedgeFundFlow(Base):
__tablename__ = "hedge_fund_flows"
id = Column(Integer, primary_key=True, index=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())
# Flow metadata
name = Column(String(200), nullable=False)
description = Column(Text, nullable=True)
# React Flow state
nodes = Column(JSON, nullable=False) # Store React Flow nodes as JSON
edges = Column(JSON, nullable=False) # Store React Flow edges as JSON
viewport = Column(JSON, nullable=True) # Store viewport state (zoom, x, y)
data = Column(JSON, nullable=True) # Store node internal states (tickers, models, etc.)
# Additional metadata
is_template = Column(Boolean, default=False) # Mark as template for reuse
tags = Column(JSON, nullable=True) # Store tags for categorization
class HedgeFundFlowRun(Base):
__tablename__ = "hedge_fund_flow_runs"
id = Column(Integer, primary_key=True, index=True)
flow_id = Column(Integer, ForeignKey("hedge_fund_flows.id"), nullable=False, index=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())
# Run execution tracking
status = Column(String(50), nullable=False, default="IDLE") # IDLE, IN_PROGRESS, COMPLETE, ERROR
started_at = Column(DateTime(timezone=True), nullable=True)
completed_at = Column(DateTime(timezone=True), nullable=True)
# Run configuration
trading_mode = Column(String(50), nullable=False, default="one-time") # one-time, continuous, advisory
schedule = Column(String(50), nullable=True) # hourly, daily, weekly (for continuous mode)
duration = Column(String(50), nullable=True) # 1day, 1week, 1month (for continuous mode)
# Run data
request_data = Column(JSON, nullable=True) # Store the request parameters (tickers, agents, models, etc.)
initial_portfolio = Column(JSON, nullable=True) # Store initial portfolio state
final_portfolio = Column(JSON, nullable=True) # Store final portfolio state
results = Column(JSON, nullable=True) # Store the output/results from the run
error_message = Column(Text, nullable=True) # Store error details if run failed
# Metadata
run_number = Column(Integer, nullable=False, default=1) # Sequential run number for this flow
class HedgeFundFlowRunCycle(Base):
__tablename__ = "hedge_fund_flow_run_cycles"
id = Column(Integer, primary_key=True, index=True)
flow_run_id = Column(Integer, ForeignKey("hedge_fund_flow_runs.id"), nullable=False, index=True)
cycle_number = Column(Integer, nullable=False) # 1, 2, 3, etc. within the run
# Timing
created_at = Column(DateTime(timezone=True), server_default=func.now())
started_at = Column(DateTime(timezone=True), nullable=False)
completed_at = Column(DateTime(timezone=True), nullable=True)
# Analysis results
analyst_signals = Column(JSON, nullable=True) # All agent decisions/signals
trading_decisions = Column(JSON, nullable=True) # Portfolio manager decisions
executed_trades = Column(JSON, nullable=True) # Actual trades executed (paper trading)
# Portfolio state after this cycle
portfolio_snapshot = Column(JSON, nullable=True) # Cash, positions, performance metrics
# Performance metrics for this cycle
performance_metrics = Column(JSON, nullable=True) # Returns, sharpe ratio, etc.
# Execution tracking
status = Column(String(50), nullable=False, default="IN_PROGRESS") # IN_PROGRESS, COMPLETED, ERROR
error_message = Column(Text, nullable=True) # Store error details if cycle failed
# Cost tracking
llm_calls_count = Column(Integer, nullable=True, default=0) # Number of LLM calls made
api_calls_count = Column(Integer, nullable=True, default=0) # Number of financial API calls made
estimated_cost = Column(String(20), nullable=True) # Estimated cost in USD
# Metadata
trigger_reason = Column(String(100), nullable=True) # scheduled, manual, market_event, etc.
market_conditions = Column(JSON, nullable=True) # Market data snapshot at cycle start
class ApiKey(Base):
__tablename__ = "api_keys"
id = Column(Integer, primary_key=True, index=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())
# API key details
provider = Column(String(100), nullable=False, unique=True, index=True) # e.g., "ANTHROPIC_API_KEY"
key_value = Column(Text, nullable=False) # The actual API key (encrypted in production)
is_active = Column(Boolean, default=True) # Enable/disable without deletion
# Optional metadata
description = Column(Text, nullable=True) # Human-readable description
last_used = Column(DateTime(timezone=True), nullable=True) # Track usage
| --- +++ @@ -4,6 +4,7 @@
class HedgeFundFlow(Base):
+ """Table to store React Flow configurations (nodes, edges, viewport)"""
__tablename__ = "hedge_fund_flows"
id = Column(Integer, primary_key=True, index=True)
@@ -26,6 +27,7 @@
class HedgeFundFlowRun(Base):
+ """Table to track individual execution runs of a hedge fund flow"""
__tablename__ = "hedge_fund_flow_runs"
id = Column(Integer, primary_key=True, index=True)
@@ -55,6 +57,7 @@
class HedgeFundFlowRunCycle(Base):
+ """Individual analysis cycles within a trading session"""
__tablename__ = "hedge_fund_flow_run_cycles"
id = Column(Integer, primary_key=True, index=True)
@@ -92,6 +95,7 @@
class ApiKey(Base):
+ """Table to store API keys for various services"""
__tablename__ = "api_keys"
id = Column(Integer, primary_key=True, index=True)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/database/models.py |
Improve my code by adding docstrings | from datetime import datetime, timedelta
from pydantic import BaseModel, Field, field_validator
from typing import List, Optional, Dict, Any
from src.llm.models import ModelProvider
from enum import Enum
from app.backend.services.graph import extract_base_agent_key
class FlowRunStatus(str, Enum):
IDLE = "IDLE"
IN_PROGRESS = "IN_PROGRESS"
COMPLETE = "COMPLETE"
ERROR = "ERROR"
class AgentModelConfig(BaseModel):
agent_id: str
model_name: Optional[str] = None
model_provider: Optional[ModelProvider] = None
class PortfolioPosition(BaseModel):
ticker: str
quantity: float
trade_price: float
@field_validator('trade_price')
@classmethod
def price_must_be_positive(cls, v: float) -> float:
if v <= 0:
raise ValueError('Trade price must be positive!')
return v
class GraphNode(BaseModel):
id: str
type: Optional[str] = None
data: Optional[Dict[str, Any]] = None
position: Optional[Dict[str, Any]] = None
class GraphEdge(BaseModel):
id: str
source: str
target: str
type: Optional[str] = None
data: Optional[Dict[str, Any]] = None
class HedgeFundResponse(BaseModel):
decisions: dict
analyst_signals: dict
class ErrorResponse(BaseModel):
message: str
error: str | None = None
# Base class for shared fields between HedgeFundRequest and BacktestRequest
class BaseHedgeFundRequest(BaseModel):
tickers: List[str]
graph_nodes: List[GraphNode]
graph_edges: List[GraphEdge]
agent_models: Optional[List[AgentModelConfig]] = None
model_name: Optional[str] = "gpt-4.1"
model_provider: Optional[ModelProvider] = ModelProvider.OPENAI
margin_requirement: float = 0.0
portfolio_positions: Optional[List[PortfolioPosition]] = None
api_keys: Optional[Dict[str, str]] = None
def get_agent_ids(self) -> List[str]:
return [node.id for node in self.graph_nodes]
def get_agent_model_config(self, agent_id: str) -> tuple[str, ModelProvider]:
if self.agent_models:
# Extract base agent key from unique node ID for matching
base_agent_key = extract_base_agent_key(agent_id)
for config in self.agent_models:
# Check both unique node ID and base agent key for matches
config_base_key = extract_base_agent_key(config.agent_id)
if config.agent_id == agent_id or config_base_key == base_agent_key:
return (
config.model_name or self.model_name,
config.model_provider or self.model_provider
)
# Fallback to global model settings
return self.model_name, self.model_provider
class BacktestRequest(BaseHedgeFundRequest):
start_date: str
end_date: str
initial_capital: float = 100000.0
class BacktestDayResult(BaseModel):
date: str
portfolio_value: float
cash: float
decisions: Dict[str, Any]
executed_trades: Dict[str, int]
analyst_signals: Dict[str, Any]
current_prices: Dict[str, float]
long_exposure: float
short_exposure: float
gross_exposure: float
net_exposure: float
long_short_ratio: Optional[float] = None
class BacktestPerformanceMetrics(BaseModel):
sharpe_ratio: Optional[float] = None
sortino_ratio: Optional[float] = None
max_drawdown: Optional[float] = None
max_drawdown_date: Optional[str] = None
long_short_ratio: Optional[float] = None
gross_exposure: Optional[float] = None
net_exposure: Optional[float] = None
class BacktestResponse(BaseModel):
results: List[BacktestDayResult]
performance_metrics: BacktestPerformanceMetrics
final_portfolio: Dict[str, Any]
class HedgeFundRequest(BaseHedgeFundRequest):
end_date: Optional[str] = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
start_date: Optional[str] = None
initial_cash: float = 100000.0
def get_start_date(self) -> str:
if self.start_date:
return self.start_date
return (datetime.strptime(self.end_date, "%Y-%m-%d") - timedelta(days=90)).strftime("%Y-%m-%d")
# Flow-related schemas
class FlowCreateRequest(BaseModel):
name: str = Field(..., min_length=1, max_length=200)
description: Optional[str] = None
nodes: List[Dict[str, Any]]
edges: List[Dict[str, Any]]
viewport: Optional[Dict[str, Any]] = None
data: Optional[Dict[str, Any]] = None
is_template: bool = False
tags: Optional[List[str]] = None
class FlowUpdateRequest(BaseModel):
name: Optional[str] = Field(None, min_length=1, max_length=200)
description: Optional[str] = None
nodes: Optional[List[Dict[str, Any]]] = None
edges: Optional[List[Dict[str, Any]]] = None
viewport: Optional[Dict[str, Any]] = None
data: Optional[Dict[str, Any]] = None
is_template: Optional[bool] = None
tags: Optional[List[str]] = None
class FlowResponse(BaseModel):
id: int
name: str
description: Optional[str]
nodes: List[Dict[str, Any]]
edges: List[Dict[str, Any]]
viewport: Optional[Dict[str, Any]]
data: Optional[Dict[str, Any]]
is_template: bool
tags: Optional[List[str]]
created_at: datetime
updated_at: Optional[datetime]
class Config:
from_attributes = True
class FlowSummaryResponse(BaseModel):
id: int
name: str
description: Optional[str]
is_template: bool
tags: Optional[List[str]]
created_at: datetime
updated_at: Optional[datetime]
class Config:
from_attributes = True
# Flow Run schemas
class FlowRunCreateRequest(BaseModel):
request_data: Optional[Dict[str, Any]] = None
class FlowRunUpdateRequest(BaseModel):
status: Optional[FlowRunStatus] = None
results: Optional[Dict[str, Any]] = None
error_message: Optional[str] = None
class FlowRunResponse(BaseModel):
id: int
flow_id: int
status: FlowRunStatus
run_number: int
created_at: datetime
updated_at: Optional[datetime]
started_at: Optional[datetime]
completed_at: Optional[datetime]
request_data: Optional[Dict[str, Any]]
results: Optional[Dict[str, Any]]
error_message: Optional[str]
class Config:
from_attributes = True
class FlowRunSummaryResponse(BaseModel):
id: int
flow_id: int
status: FlowRunStatus
run_number: int
created_at: datetime
started_at: Optional[datetime]
completed_at: Optional[datetime]
error_message: Optional[str]
class Config:
from_attributes = True
# API Key schemas
class ApiKeyCreateRequest(BaseModel):
provider: str = Field(..., min_length=1, max_length=100)
key_value: str = Field(..., min_length=1)
description: Optional[str] = None
is_active: bool = True
class ApiKeyUpdateRequest(BaseModel):
key_value: Optional[str] = Field(None, min_length=1)
description: Optional[str] = None
is_active: Optional[bool] = None
class ApiKeyResponse(BaseModel):
id: int
provider: str
key_value: str
is_active: bool
description: Optional[str]
created_at: datetime
updated_at: Optional[datetime]
last_used: Optional[datetime]
class Config:
from_attributes = True
class ApiKeySummaryResponse(BaseModel):
id: int
provider: str
is_active: bool
description: Optional[str]
created_at: datetime
updated_at: Optional[datetime]
last_used: Optional[datetime]
has_key: bool = True # Indicates if a key is set
class Config:
from_attributes = True
class ApiKeyBulkUpdateRequest(BaseModel):
api_keys: List[ApiKeyCreateRequest] | --- +++ @@ -70,9 +70,11 @@ api_keys: Optional[Dict[str, str]] = None
def get_agent_ids(self) -> List[str]:
+ """Extract agent IDs from graph structure"""
return [node.id for node in self.graph_nodes]
def get_agent_model_config(self, agent_id: str) -> tuple[str, ModelProvider]:
+ """Get model configuration for a specific agent"""
if self.agent_models:
# Extract base agent key from unique node ID for matching
base_agent_key = extract_base_agent_key(agent_id)
@@ -132,6 +134,7 @@ initial_cash: float = 100000.0
def get_start_date(self) -> str:
+ """Calculate start date if not provided"""
if self.start_date:
return self.start_date
return (datetime.strptime(self.end_date, "%Y-%m-%d") - timedelta(days=90)).strftime("%Y-%m-%d")
@@ -178,6 +181,7 @@
class FlowSummaryResponse(BaseModel):
+ """Lightweight flow response without nodes/edges for listing"""
id: int
name: str
description: Optional[str]
@@ -192,16 +196,19 @@
# Flow Run schemas
class FlowRunCreateRequest(BaseModel):
+ """Request to create a new flow run"""
request_data: Optional[Dict[str, Any]] = None
class FlowRunUpdateRequest(BaseModel):
+ """Request to update an existing flow run"""
status: Optional[FlowRunStatus] = None
results: Optional[Dict[str, Any]] = None
error_message: Optional[str] = None
class FlowRunResponse(BaseModel):
+ """Complete flow run response"""
id: int
flow_id: int
status: FlowRunStatus
@@ -219,6 +226,7 @@
class FlowRunSummaryResponse(BaseModel):
+ """Lightweight flow run response for listing"""
id: int
flow_id: int
status: FlowRunStatus
@@ -234,6 +242,7 @@
# API Key schemas
class ApiKeyCreateRequest(BaseModel):
+ """Request to create or update an API key"""
provider: str = Field(..., min_length=1, max_length=100)
key_value: str = Field(..., min_length=1)
description: Optional[str] = None
@@ -241,12 +250,14 @@
class ApiKeyUpdateRequest(BaseModel):
+ """Request to update an existing API key"""
key_value: Optional[str] = Field(None, min_length=1)
description: Optional[str] = None
is_active: Optional[bool] = None
class ApiKeyResponse(BaseModel):
+ """Complete API key response"""
id: int
provider: str
key_value: str
@@ -261,6 +272,7 @@
class ApiKeySummaryResponse(BaseModel):
+ """API key response without the actual key value"""
id: int
provider: str
is_active: bool
@@ -275,4 +287,5 @@
class ApiKeyBulkUpdateRequest(BaseModel):
- api_keys: List[ApiKeyCreateRequest]+ """Request to update multiple API keys at once"""
+ api_keys: List[ApiKeyCreateRequest]
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/models/schemas.py |
Write docstrings describing functionality | from sqlalchemy.orm import Session
from typing import Dict, Optional
from app.backend.repositories.api_key_repository import ApiKeyRepository
class ApiKeyService:
def __init__(self, db: Session):
self.repository = ApiKeyRepository(db)
def get_api_keys_dict(self) -> Dict[str, str]:
api_keys = self.repository.get_all_api_keys(include_inactive=False)
return {key.provider: key.key_value for key in api_keys}
def get_api_key(self, provider: str) -> Optional[str]:
api_key = self.repository.get_api_key_by_provider(provider)
return api_key.key_value if api_key else None | --- +++ @@ -4,14 +4,20 @@
class ApiKeyService:
+ """Simple service to load API keys for requests"""
def __init__(self, db: Session):
self.repository = ApiKeyRepository(db)
def get_api_keys_dict(self) -> Dict[str, str]:
+ """
+ Load all active API keys from database and return as a dictionary
+ suitable for injecting into requests
+ """
api_keys = self.repository.get_all_api_keys(include_inactive=False)
return {key.provider: key.key_value for key in api_keys}
def get_api_key(self, provider: str) -> Optional[str]:
+ """Get a specific API key by provider"""
api_key = self.repository.get_api_key_by_provider(provider)
return api_key.key_value if api_key else None | https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/services/api_key_service.py |
Improve my code by adding docstrings | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
from src.utils.api_key import get_api_key_from_state
class CathieWoodSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def cathie_wood_agent(state: AgentState, agent_id: str = "cathie_wood_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
cw_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
# Request multiple periods of data (annual or TTM) for a more robust view.
financial_line_items = search_line_items(
ticker,
[
"revenue",
"gross_margin",
"operating_margin",
"debt_to_equity",
"free_cash_flow",
"total_assets",
"total_liabilities",
"dividends_and_other_cash_distributions",
"outstanding_shares",
"research_and_development",
"capital_expenditure",
"operating_expense",
],
end_date,
period="annual",
limit=5,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing disruptive potential")
disruptive_analysis = analyze_disruptive_potential(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing innovation-driven growth")
innovation_analysis = analyze_innovation_growth(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Calculating valuation & high-growth scenario")
valuation_analysis = analyze_cathie_wood_valuation(financial_line_items, market_cap)
# Combine partial scores or signals
total_score = disruptive_analysis["score"] + innovation_analysis["score"] + valuation_analysis["score"]
max_possible_score = 15 # Adjust weighting as desired
if total_score >= 0.7 * max_possible_score:
signal = "bullish"
elif total_score <= 0.3 * max_possible_score:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {"signal": signal, "score": total_score, "max_score": max_possible_score, "disruptive_analysis": disruptive_analysis, "innovation_analysis": innovation_analysis, "valuation_analysis": valuation_analysis}
progress.update_status(agent_id, ticker, "Generating Cathie Wood analysis")
cw_output = generate_cathie_wood_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
cw_analysis[ticker] = {"signal": cw_output.signal, "confidence": cw_output.confidence, "reasoning": cw_output.reasoning}
progress.update_status(agent_id, ticker, "Done", analysis=cw_output.reasoning)
message = HumanMessage(content=json.dumps(cw_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(cw_analysis, agent_id)
state["data"]["analyst_signals"][agent_id] = cw_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_disruptive_potential(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {"score": 0, "details": "Insufficient data to analyze disruptive potential"}
# 1. Revenue Growth Analysis - Check for accelerating growth
revenues = [item.revenue for item in financial_line_items if item.revenue]
if len(revenues) >= 3: # Need at least 3 periods to check acceleration
growth_rates = []
for i in range(len(revenues) - 1):
if revenues[i] and revenues[i + 1]:
growth_rate = (revenues[i] - revenues[i + 1]) / abs(revenues[i + 1]) if revenues[i + 1] != 0 else 0
growth_rates.append(growth_rate)
# Check if growth is accelerating (first growth rate higher than last, since they're in reverse order)
if len(growth_rates) >= 2 and growth_rates[0] > growth_rates[-1]:
score += 2
details.append(f"Revenue growth is accelerating: {(growth_rates[0]*100):.1f}% vs {(growth_rates[-1]*100):.1f}%")
# Check absolute growth rate (most recent growth rate is at index 0)
latest_growth = growth_rates[0] if growth_rates else 0
if latest_growth > 1.0:
score += 3
details.append(f"Exceptional revenue growth: {(latest_growth*100):.1f}%")
elif latest_growth > 0.5:
score += 2
details.append(f"Strong revenue growth: {(latest_growth*100):.1f}%")
elif latest_growth > 0.2:
score += 1
details.append(f"Moderate revenue growth: {(latest_growth*100):.1f}%")
else:
details.append("Insufficient revenue data for growth analysis")
# 2. Gross Margin Analysis - Check for expanding margins
gross_margins = [item.gross_margin for item in financial_line_items if hasattr(item, "gross_margin") and item.gross_margin is not None]
if len(gross_margins) >= 2:
margin_trend = gross_margins[0] - gross_margins[-1]
if margin_trend > 0.05: # 5% improvement
score += 2
details.append(f"Expanding gross margins: +{(margin_trend*100):.1f}%")
elif margin_trend > 0:
score += 1
details.append(f"Slightly improving gross margins: +{(margin_trend*100):.1f}%")
# Check absolute margin level (most recent margin is at index 0)
if gross_margins[0] > 0.50: # High margin business
score += 2
details.append(f"High gross margin: {(gross_margins[0]*100):.1f}%")
else:
details.append("Insufficient gross margin data")
# 3. Operating Leverage Analysis
revenues = [item.revenue for item in financial_line_items if item.revenue]
operating_expenses = [item.operating_expense for item in financial_line_items if hasattr(item, "operating_expense") and item.operating_expense]
if len(revenues) >= 2 and len(operating_expenses) >= 2:
rev_growth = (revenues[0] - revenues[-1]) / abs(revenues[-1])
opex_growth = (operating_expenses[0] - operating_expenses[-1]) / abs(operating_expenses[-1])
if rev_growth > opex_growth:
score += 2
details.append("Positive operating leverage: Revenue growing faster than expenses")
else:
details.append("Insufficient data for operating leverage analysis")
# 4. R&D Investment Analysis
rd_expenses = [item.research_and_development for item in financial_line_items if hasattr(item, "research_and_development") and item.research_and_development is not None]
if rd_expenses and revenues:
rd_intensity = rd_expenses[0] / revenues[0]
if rd_intensity > 0.15: # High R&D intensity
score += 3
details.append(f"High R&D investment: {(rd_intensity*100):.1f}% of revenue")
elif rd_intensity > 0.08:
score += 2
details.append(f"Moderate R&D investment: {(rd_intensity*100):.1f}% of revenue")
elif rd_intensity > 0.05:
score += 1
details.append(f"Some R&D investment: {(rd_intensity*100):.1f}% of revenue")
else:
details.append("No R&D data available")
# Normalize score to be out of 5
max_possible_score = 12 # Sum of all possible points
normalized_score = (score / max_possible_score) * 5
return {"score": normalized_score, "details": "; ".join(details), "raw_score": score, "max_score": max_possible_score}
def analyze_innovation_growth(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {"score": 0, "details": "Insufficient data to analyze innovation-driven growth"}
# 1. R&D Investment Trends
rd_expenses = [item.research_and_development for item in financial_line_items if hasattr(item, "research_and_development") and item.research_and_development]
revenues = [item.revenue for item in financial_line_items if item.revenue]
if rd_expenses and revenues and len(rd_expenses) >= 2:
rd_growth = (rd_expenses[0] - rd_expenses[-1]) / abs(rd_expenses[-1]) if rd_expenses[-1] != 0 else 0
if rd_growth > 0.5: # 50% growth in R&D
score += 3
details.append(f"Strong R&D investment growth: +{(rd_growth*100):.1f}%")
elif rd_growth > 0.2:
score += 2
details.append(f"Moderate R&D investment growth: +{(rd_growth*100):.1f}%")
# Check R&D intensity trend (corrected for reverse chronological order)
rd_intensity_start = rd_expenses[-1] / revenues[-1]
rd_intensity_end = rd_expenses[0] / revenues[0]
if rd_intensity_end > rd_intensity_start:
score += 2
details.append(f"Increasing R&D intensity: {(rd_intensity_end*100):.1f}% vs {(rd_intensity_start*100):.1f}%")
else:
details.append("Insufficient R&D data for trend analysis")
# 2. Free Cash Flow Analysis
fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
if fcf_vals and len(fcf_vals) >= 2:
fcf_growth = (fcf_vals[0] - fcf_vals[-1]) / abs(fcf_vals[-1])
positive_fcf_count = sum(1 for f in fcf_vals if f > 0)
if fcf_growth > 0.3 and positive_fcf_count == len(fcf_vals):
score += 3
details.append("Strong and consistent FCF growth, excellent innovation funding capacity")
elif positive_fcf_count >= len(fcf_vals) * 0.75:
score += 2
details.append("Consistent positive FCF, good innovation funding capacity")
elif positive_fcf_count > len(fcf_vals) * 0.5:
score += 1
details.append("Moderately consistent FCF, adequate innovation funding capacity")
else:
details.append("Insufficient FCF data for analysis")
# 3. Operating Efficiency Analysis
op_margin_vals = [item.operating_margin for item in financial_line_items if item.operating_margin]
if op_margin_vals and len(op_margin_vals) >= 2:
margin_trend = op_margin_vals[0] - op_margin_vals[-1]
if op_margin_vals[0] > 0.15 and margin_trend > 0:
score += 3
details.append(f"Strong and improving operating margin: {(op_margin_vals[0]*100):.1f}%")
elif op_margin_vals[0] > 0.10:
score += 2
details.append(f"Healthy operating margin: {(op_margin_vals[0]*100):.1f}%")
elif margin_trend > 0:
score += 1
details.append("Improving operating efficiency")
else:
details.append("Insufficient operating margin data")
# 4. Capital Allocation Analysis
capex = [item.capital_expenditure for item in financial_line_items if hasattr(item, "capital_expenditure") and item.capital_expenditure]
if capex and revenues and len(capex) >= 2:
capex_intensity = abs(capex[0]) / revenues[0]
capex_growth = (abs(capex[0]) - abs(capex[-1])) / abs(capex[-1]) if capex[-1] != 0 else 0
if capex_intensity > 0.10 and capex_growth > 0.2:
score += 2
details.append("Strong investment in growth infrastructure")
elif capex_intensity > 0.05:
score += 1
details.append("Moderate investment in growth infrastructure")
else:
details.append("Insufficient CAPEX data")
# 5. Growth Reinvestment Analysis
dividends = [item.dividends_and_other_cash_distributions for item in financial_line_items if hasattr(item, "dividends_and_other_cash_distributions") and item.dividends_and_other_cash_distributions]
if dividends and fcf_vals:
latest_payout_ratio = dividends[0] / fcf_vals[0] if fcf_vals[0] != 0 else 1
if latest_payout_ratio < 0.2: # Low dividend payout ratio suggests reinvestment focus
score += 2
details.append("Strong focus on reinvestment over dividends")
elif latest_payout_ratio < 0.4:
score += 1
details.append("Moderate focus on reinvestment over dividends")
else:
details.append("Insufficient dividend data")
# Normalize score to be out of 5
max_possible_score = 15 # Sum of all possible points
normalized_score = (score / max_possible_score) * 5
return {"score": normalized_score, "details": "; ".join(details), "raw_score": score, "max_score": max_possible_score}
def analyze_cathie_wood_valuation(financial_line_items: list, market_cap: float) -> dict:
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data for valuation"}
latest = financial_line_items[0]
fcf = latest.free_cash_flow if latest.free_cash_flow else 0
if fcf <= 0:
return {"score": 0, "details": f"No positive FCF for valuation; FCF = {fcf}", "intrinsic_value": None}
# Instead of a standard DCF, let's assume a higher growth rate for an innovative company.
# Example values:
growth_rate = 0.20 # 20% annual growth
discount_rate = 0.15
terminal_multiple = 25
projection_years = 5
present_value = 0
for year in range(1, projection_years + 1):
future_fcf = fcf * (1 + growth_rate) ** year
pv = future_fcf / ((1 + discount_rate) ** year)
present_value += pv
# Terminal Value
terminal_value = (fcf * (1 + growth_rate) ** projection_years * terminal_multiple) / ((1 + discount_rate) ** projection_years)
intrinsic_value = present_value + terminal_value
margin_of_safety = (intrinsic_value - market_cap) / market_cap
score = 0
if margin_of_safety > 0.5:
score += 3
elif margin_of_safety > 0.2:
score += 1
details = [f"Calculated intrinsic value: ~{intrinsic_value:,.2f}", f"Market cap: ~{market_cap:,.2f}", f"Margin of safety: {margin_of_safety:.2%}"]
return {"score": score, "details": "; ".join(details), "intrinsic_value": intrinsic_value, "margin_of_safety": margin_of_safety}
def generate_cathie_wood_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str = "cathie_wood_agent",
) -> CathieWoodSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Cathie Wood AI agent, making investment decisions using her principles:
1. Seek companies leveraging disruptive innovation.
2. Emphasize exponential growth potential, large TAM.
3. Focus on technology, healthcare, or other future-facing sectors.
4. Consider multi-year time horizons for potential breakthroughs.
5. Accept higher volatility in pursuit of high returns.
6. Evaluate management's vision and ability to invest in R&D.
Rules:
- Identify disruptive or breakthrough technology.
- Evaluate strong potential for multi-year revenue growth.
- Check if the company can scale effectively in a large market.
- Use a growth-biased valuation approach.
- Provide a data-driven recommendation (bullish, bearish, or neutral).
When providing your reasoning, be thorough and specific by:
1. Identifying the specific disruptive technologies/innovations the company is leveraging
2. Highlighting growth metrics that indicate exponential potential (revenue acceleration, expanding TAM)
3. Discussing the long-term vision and transformative potential over 5+ year horizons
4. Explaining how the company might disrupt traditional industries or create new markets
5. Addressing R&D investment and innovation pipeline that could drive future growth
6. Using Cathie Wood's optimistic, future-focused, and conviction-driven voice
For example, if bullish: "The company's AI-driven platform is transforming the $500B healthcare analytics market, with evidence of platform adoption accelerating from 40% to 65% YoY. Their R&D investments of 22% of revenue are creating a technological moat that positions them to capture a significant share of this expanding market. The current valuation doesn't reflect the exponential growth trajectory we expect as..."
For example, if bearish: "While operating in the genomics space, the company lacks truly disruptive technology and is merely incrementally improving existing techniques. R&D spending at only 8% of revenue signals insufficient investment in breakthrough innovation. With revenue growth slowing from 45% to 20% YoY, there's limited evidence of the exponential adoption curve we look for in transformative companies..."
""",
),
(
"human",
"""Based on the following analysis, create a Cathie Wood-style investment signal.
Analysis Data for {ticker}:
{analysis_data}
Return the trading signal in this JSON format:
{{
"signal": "bullish/bearish/neutral",
"confidence": float (0-100),
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def create_default_cathie_wood_signal():
return CathieWoodSignal(signal="neutral", confidence=0.0, reasoning="Error in analysis, defaulting to neutral")
return call_llm(
prompt=prompt,
pydantic_model=CathieWoodSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_cathie_wood_signal,
)
# source: https://ark-invest.com | --- +++ @@ -17,6 +17,13 @@
def cathie_wood_agent(state: AgentState, agent_id: str = "cathie_wood_agent"):
+ """
+ Analyzes stocks using Cathie Wood's investing principles and LLM reasoning.
+ 1. Prioritizes companies with breakthrough technologies or business models
+ 2. Focuses on industries with rapid adoption curves and massive TAM (Total Addressable Market).
+ 3. Invests mostly in AI, robotics, genomic sequencing, fintech, and blockchain.
+ 4. Willing to endure short-term volatility for long-term gains.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -102,6 +109,15 @@
def analyze_disruptive_potential(metrics: list, financial_line_items: list) -> dict:
+ """
+ Analyze whether the company has disruptive products, technology, or business model.
+ Evaluates multiple dimensions of disruptive potential:
+ 1. Revenue Growth Acceleration - indicates market adoption
+ 2. R&D Intensity - shows innovation investment
+ 3. Gross Margin Trends - suggests pricing power and scalability
+ 4. Operating Leverage - demonstrates business model efficiency
+ 5. Market Share Dynamics - indicates competitive position
+ """
score = 0
details = []
@@ -192,6 +208,15 @@
def analyze_innovation_growth(metrics: list, financial_line_items: list) -> dict:
+ """
+ Evaluate the company's commitment to innovation and potential for exponential growth.
+ Analyzes multiple dimensions:
+ 1. R&D Investment Trends - measures commitment to innovation
+ 2. Free Cash Flow Generation - indicates ability to fund innovation
+ 3. Operating Efficiency - shows scalability of innovation
+ 4. Capital Allocation - reveals innovation-focused management
+ 5. Growth Reinvestment - demonstrates commitment to future growth
+ """
score = 0
details = []
@@ -291,6 +316,11 @@
def analyze_cathie_wood_valuation(financial_line_items: list, market_cap: float) -> dict:
+ """
+ Cathie Wood often focuses on long-term exponential growth potential. We can do
+ a simplified approach looking for a large total addressable market (TAM) and the
+ company's ability to capture a sizable portion.
+ """
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data for valuation"}
@@ -336,6 +366,9 @@ state: AgentState,
agent_id: str = "cathie_wood_agent",
) -> CathieWoodSignal:
+ """
+ Generates investment decisions in the style of Cathie Wood.
+ """
template = ChatPromptTemplate.from_messages(
[
(
@@ -400,4 +433,4 @@ )
-# source: https://ark-invest.com+# source: https://ark-invest.com
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/cathie_wood.py |
Create Google-style docstrings for my code | from typing import List, Optional, Dict, Any
from datetime import datetime
from sqlalchemy.orm import Session
from sqlalchemy import desc, func
from app.backend.database.models import HedgeFundFlowRun
from app.backend.models.schemas import FlowRunStatus
class FlowRunRepository:
def __init__(self, db: Session):
self.db = db
def create_flow_run(self, flow_id: int, request_data: Dict[str, Any] = None) -> HedgeFundFlowRun:
# Get the next run number for this flow
run_number = self._get_next_run_number(flow_id)
flow_run = HedgeFundFlowRun(
flow_id=flow_id,
request_data=request_data,
run_number=run_number,
status=FlowRunStatus.IDLE.value
)
self.db.add(flow_run)
self.db.commit()
self.db.refresh(flow_run)
return flow_run
def get_flow_run_by_id(self, run_id: int) -> Optional[HedgeFundFlowRun]:
return self.db.query(HedgeFundFlowRun).filter(HedgeFundFlowRun.id == run_id).first()
def get_flow_runs_by_flow_id(self, flow_id: int, limit: int = 50, offset: int = 0) -> List[HedgeFundFlowRun]:
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
.order_by(desc(HedgeFundFlowRun.created_at))
.limit(limit)
.offset(offset)
.all()
)
def get_active_flow_run(self, flow_id: int) -> Optional[HedgeFundFlowRun]:
return (
self.db.query(HedgeFundFlowRun)
.filter(
HedgeFundFlowRun.flow_id == flow_id,
HedgeFundFlowRun.status == FlowRunStatus.IN_PROGRESS.value
)
.first()
)
def get_latest_flow_run(self, flow_id: int) -> Optional[HedgeFundFlowRun]:
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
.order_by(desc(HedgeFundFlowRun.created_at))
.first()
)
def update_flow_run(
self,
run_id: int,
status: Optional[FlowRunStatus] = None,
results: Optional[Dict[str, Any]] = None,
error_message: Optional[str] = None
) -> Optional[HedgeFundFlowRun]:
flow_run = self.get_flow_run_by_id(run_id)
if not flow_run:
return None
# Update status and timing
if status is not None:
flow_run.status = status.value
# Update timing based on status
if status == FlowRunStatus.IN_PROGRESS and not flow_run.started_at:
flow_run.started_at = datetime.utcnow()
elif status in [FlowRunStatus.COMPLETE, FlowRunStatus.ERROR] and not flow_run.completed_at:
flow_run.completed_at = datetime.utcnow()
# Update results and error message
if results is not None:
flow_run.results = results
if error_message is not None:
flow_run.error_message = error_message
self.db.commit()
self.db.refresh(flow_run)
return flow_run
def delete_flow_run(self, run_id: int) -> bool:
flow_run = self.get_flow_run_by_id(run_id)
if not flow_run:
return False
self.db.delete(flow_run)
self.db.commit()
return True
def delete_flow_runs_by_flow_id(self, flow_id: int) -> int:
deleted_count = (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
.delete()
)
self.db.commit()
return deleted_count
def get_flow_run_count(self, flow_id: int) -> int:
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
.count()
)
def _get_next_run_number(self, flow_id: int) -> int:
max_run_number = (
self.db.query(func.max(HedgeFundFlowRun.run_number))
.filter(HedgeFundFlowRun.flow_id == flow_id)
.scalar()
)
return (max_run_number or 0) + 1 | --- +++ @@ -7,11 +7,13 @@
class FlowRunRepository:
+ """Repository for HedgeFundFlowRun CRUD operations"""
def __init__(self, db: Session):
self.db = db
def create_flow_run(self, flow_id: int, request_data: Dict[str, Any] = None) -> HedgeFundFlowRun:
+ """Create a new flow run"""
# Get the next run number for this flow
run_number = self._get_next_run_number(flow_id)
@@ -27,9 +29,11 @@ return flow_run
def get_flow_run_by_id(self, run_id: int) -> Optional[HedgeFundFlowRun]:
+ """Get a flow run by its ID"""
return self.db.query(HedgeFundFlowRun).filter(HedgeFundFlowRun.id == run_id).first()
def get_flow_runs_by_flow_id(self, flow_id: int, limit: int = 50, offset: int = 0) -> List[HedgeFundFlowRun]:
+ """Get all runs for a specific flow, ordered by most recent first"""
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
@@ -40,6 +44,7 @@ )
def get_active_flow_run(self, flow_id: int) -> Optional[HedgeFundFlowRun]:
+ """Get the current active (IN_PROGRESS) run for a flow"""
return (
self.db.query(HedgeFundFlowRun)
.filter(
@@ -50,6 +55,7 @@ )
def get_latest_flow_run(self, flow_id: int) -> Optional[HedgeFundFlowRun]:
+ """Get the most recent run for a flow"""
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
@@ -64,6 +70,7 @@ results: Optional[Dict[str, Any]] = None,
error_message: Optional[str] = None
) -> Optional[HedgeFundFlowRun]:
+ """Update an existing flow run"""
flow_run = self.get_flow_run_by_id(run_id)
if not flow_run:
return None
@@ -89,6 +96,7 @@ return flow_run
def delete_flow_run(self, run_id: int) -> bool:
+ """Delete a flow run by ID"""
flow_run = self.get_flow_run_by_id(run_id)
if not flow_run:
return False
@@ -98,6 +106,7 @@ return True
def delete_flow_runs_by_flow_id(self, flow_id: int) -> int:
+ """Delete all runs for a specific flow. Returns count of deleted runs."""
deleted_count = (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
@@ -107,6 +116,7 @@ return deleted_count
def get_flow_run_count(self, flow_id: int) -> int:
+ """Get total count of runs for a flow"""
return (
self.db.query(HedgeFundFlowRun)
.filter(HedgeFundFlowRun.flow_id == flow_id)
@@ -114,6 +124,7 @@ )
def _get_next_run_number(self, flow_id: int) -> int:
+ """Get the next run number for a flow"""
max_run_number = (
self.db.query(func.max(HedgeFundFlowRun.run_number))
.filter(HedgeFundFlowRun.flow_id == flow_id)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/repositories/flow_run_repository.py |
Write reusable docstrings | import asyncio
import json
import re
from langchain_core.messages import HumanMessage
from langgraph.graph import END, StateGraph
from app.backend.services.agent_service import create_agent_function
from src.agents.portfolio_manager import portfolio_management_agent
from src.agents.risk_manager import risk_management_agent
from src.main import start
from src.utils.analysts import ANALYST_CONFIG
from src.graph.state import AgentState
def extract_base_agent_key(unique_id: str) -> str:
# For agent nodes, remove the last underscore and 6-character suffix
parts = unique_id.split('_')
if len(parts) >= 2:
last_part = parts[-1]
# If the last part is a 6-character alphanumeric string, it's likely our suffix
if len(last_part) == 6 and re.match(r'^[a-z0-9]+$', last_part):
return '_'.join(parts[:-1])
return unique_id # Return original if no suffix pattern found
# Helper function to create the agent graph
def create_graph(graph_nodes: list, graph_edges: list) -> StateGraph:
graph = StateGraph(AgentState)
graph.add_node("start_node", start)
# Get analyst nodes from the configuration
analyst_nodes = {key: (f"{key}_agent", config["agent_func"]) for key, config in ANALYST_CONFIG.items()}
# Extract agent IDs from graph structure
agent_ids = [node.id for node in graph_nodes]
agent_ids_set = set(agent_ids)
# Track which nodes are portfolio managers for special handling
portfolio_manager_nodes = set()
# Add agent nodes
for unique_agent_id in agent_ids:
base_agent_key = extract_base_agent_key(unique_agent_id)
# Track portfolio manager nodes for special handling (before ANALYST_CONFIG check)
if base_agent_key == "portfolio_manager":
portfolio_manager_nodes.add(unique_agent_id)
continue
# Skip if the base agent key is not in our analyst configuration
if base_agent_key not in ANALYST_CONFIG:
continue
node_name, node_func = analyst_nodes[base_agent_key]
agent_function = create_agent_function(node_func, unique_agent_id)
graph.add_node(unique_agent_id, agent_function)
# Add portfolio manager nodes and their corresponding risk managers
risk_manager_nodes = {} # Map portfolio manager ID to risk manager ID
for portfolio_manager_id in portfolio_manager_nodes:
portfolio_manager_function = create_agent_function(portfolio_management_agent, portfolio_manager_id)
graph.add_node(portfolio_manager_id, portfolio_manager_function)
# Create unique risk manager for this portfolio manager
suffix = portfolio_manager_id.split('_')[-1]
risk_manager_id = f"risk_management_agent_{suffix}"
risk_manager_nodes[portfolio_manager_id] = risk_manager_id
# Add the risk manager node
risk_manager_function = create_agent_function(risk_management_agent, risk_manager_id)
graph.add_node(risk_manager_id, risk_manager_function)
# Build connections based on React Flow graph structure
nodes_with_incoming_edges = set()
nodes_with_outgoing_edges = set()
direct_to_portfolio_managers = {} # Map analyst ID to portfolio manager ID for direct connections
for edge in graph_edges:
# Only consider edges between agent nodes (not from stock tickers)
if edge.source in agent_ids_set and edge.target in agent_ids_set:
source_base_key = extract_base_agent_key(edge.source)
target_base_key = extract_base_agent_key(edge.target)
nodes_with_incoming_edges.add(edge.target)
nodes_with_outgoing_edges.add(edge.source)
# Check if this is a direct connection from analyst to portfolio manager
if (source_base_key in ANALYST_CONFIG and
source_base_key != "portfolio_manager" and
target_base_key == "portfolio_manager"):
# Don't add direct edge to portfolio manager - we'll route through risk manager
direct_to_portfolio_managers[edge.source] = edge.target
else:
# Add edge between agent nodes (but not direct to portfolio managers)
graph.add_edge(edge.source, edge.target)
# Connect start_node to nodes that don't have incoming edges from other agents
for agent_id in agent_ids:
if agent_id not in nodes_with_incoming_edges:
base_agent_key = extract_base_agent_key(agent_id)
if base_agent_key in ANALYST_CONFIG and base_agent_key != "portfolio_manager":
graph.add_edge("start_node", agent_id)
# Connect analysts that have direct connections to portfolio managers to their corresponding risk managers
for analyst_id, portfolio_manager_id in direct_to_portfolio_managers.items():
risk_manager_id = risk_manager_nodes[portfolio_manager_id]
graph.add_edge(analyst_id, risk_manager_id)
# Connect each risk manager to its corresponding portfolio manager
for portfolio_manager_id, risk_manager_id in risk_manager_nodes.items():
graph.add_edge(risk_manager_id, portfolio_manager_id)
# Connect portfolio managers to END
for portfolio_manager_id in portfolio_manager_nodes:
graph.add_edge(portfolio_manager_id, END)
# Set the entry point to the start node
graph.set_entry_point("start_node")
return graph
async def run_graph_async(graph, portfolio, tickers, start_date, end_date, model_name, model_provider, request=None):
# Use run_in_executor to run the synchronous function in a separate thread
# so it doesn't block the event loop
loop = asyncio.get_running_loop()
result = await loop.run_in_executor(None, lambda: run_graph(graph, portfolio, tickers, start_date, end_date, model_name, model_provider, request)) # Use default executor
return result
def run_graph(
graph: StateGraph,
portfolio: dict,
tickers: list[str],
start_date: str,
end_date: str,
model_name: str,
model_provider: str,
request=None,
) -> dict:
return graph.invoke(
{
"messages": [
HumanMessage(
content="Make trading decisions based on the provided data.",
)
],
"data": {
"tickers": tickers,
"portfolio": portfolio,
"start_date": start_date,
"end_date": end_date,
"analyst_signals": {},
},
"metadata": {
"show_reasoning": False,
"model_name": model_name,
"model_provider": model_provider,
"request": request, # Pass the request for agent-specific model access
},
},
)
def parse_hedge_fund_response(response):
try:
return json.loads(response)
except json.JSONDecodeError as e:
print(f"JSON decoding error: {e}\nResponse: {repr(response)}")
return None
except TypeError as e:
print(f"Invalid response type (expected string, got {type(response).__name__}): {e}")
return None
except Exception as e:
print(f"Unexpected error while parsing response: {e}\nResponse: {repr(response)}")
return None | --- +++ @@ -13,6 +13,15 @@
def extract_base_agent_key(unique_id: str) -> str:
+ """
+ Extract the base agent key from a unique node ID.
+
+ Args:
+ unique_id: The unique node ID with suffix (e.g., "warren_buffett_abc123")
+
+ Returns:
+ The base agent key (e.g., "warren_buffett")
+ """
# For agent nodes, remove the last underscore and 6-character suffix
parts = unique_id.split('_')
if len(parts) >= 2:
@@ -25,6 +34,7 @@
# Helper function to create the agent graph
def create_graph(graph_nodes: list, graph_edges: list) -> StateGraph:
+ """Create the workflow based on the React Flow graph structure."""
graph = StateGraph(AgentState)
graph.add_node("start_node", start)
@@ -120,6 +130,7 @@
async def run_graph_async(graph, portfolio, tickers, start_date, end_date, model_name, model_provider, request=None):
+ """Async wrapper for run_graph to work with asyncio."""
# Use run_in_executor to run the synchronous function in a separate thread
# so it doesn't block the event loop
loop = asyncio.get_running_loop()
@@ -137,6 +148,11 @@ model_provider: str,
request=None,
) -> dict:
+ """
+ Run the graph with the given portfolio, tickers,
+ start date, end date, show reasoning, model name,
+ and model provider.
+ """
return graph.invoke(
{
"messages": [
@@ -162,6 +178,7 @@
def parse_hedge_fund_response(response):
+ """Parses a JSON string and returns a dictionary."""
try:
return json.loads(response)
except json.JSONDecodeError as e:
@@ -172,4 +189,4 @@ return None
except Exception as e:
print(f"Unexpected error while parsing response: {e}\nResponse: {repr(response)}")
- return None+ return None
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/services/graph.py |
Add docstrings that explain logic | from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from alembic import context
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
if config.config_file_name is not None:
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
from app.backend.database.models import Base
target_metadata = Base.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline() -> None:
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online() | --- +++ @@ -26,6 +26,17 @@
def run_migrations_offline() -> None:
+ """Run migrations in 'offline' mode.
+
+ This configures the context with just a URL
+ and not an Engine, though an Engine is acceptable
+ here as well. By skipping the Engine creation
+ we don't even need a DBAPI to be available.
+
+ Calls to context.execute() here emit the given string to the
+ script output.
+
+ """
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
@@ -39,6 +50,12 @@
def run_migrations_online() -> None:
+ """Run migrations in 'online' mode.
+
+ In this scenario we need to create an Engine
+ and associate a connection with the context.
+
+ """
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
@@ -57,4 +74,4 @@ if context.is_offline_mode():
run_migrations_offline()
else:
- run_migrations_online()+ run_migrations_online()
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/alembic/env.py |
Write docstrings for this repository | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items, get_insider_trades, get_company_news
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
from src.utils.api_key import get_api_key_from_state
class CharlieMungerSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: int
reasoning: str
def charlie_munger_agent(state: AgentState, agent_id: str = "charlie_munger_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
munger_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key) # Munger looks at longer periods
progress.update_status(agent_id, ticker, "Gathering financial line items")
financial_line_items = search_line_items(
ticker,
[
"revenue",
"net_income",
"operating_income",
"return_on_invested_capital",
"gross_margin",
"operating_margin",
"free_cash_flow",
"capital_expenditure",
"cash_and_equivalents",
"total_debt",
"shareholders_equity",
"outstanding_shares",
"research_and_development",
"goodwill_and_intangible_assets",
],
end_date,
period="annual",
limit=10, # Munger examines long-term trends
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching insider trades")
# Munger values management with skin in the game
insider_trades = get_insider_trades(
ticker,
end_date,
limit=100,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Fetching company news")
# Munger avoids businesses with frequent negative press
company_news = get_company_news(
ticker,
end_date,
limit=10,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Analyzing moat strength")
moat_analysis = analyze_moat_strength(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing management quality")
management_analysis = analyze_management_quality(financial_line_items, insider_trades)
progress.update_status(agent_id, ticker, "Analyzing business predictability")
predictability_analysis = analyze_predictability(financial_line_items)
progress.update_status(agent_id, ticker, "Calculating Munger-style valuation")
valuation_analysis = calculate_munger_valuation(financial_line_items, market_cap)
# Combine partial scores with Munger's weighting preferences
# Munger weights quality and predictability higher than current valuation
total_score = (
moat_analysis["score"] * 0.35 +
management_analysis["score"] * 0.25 +
predictability_analysis["score"] * 0.25 +
valuation_analysis["score"] * 0.15
)
max_possible_score = 10 # Scale to 0-10
# Generate a simple buy/hold/sell signal
if total_score >= 7.5: # Munger has very high standards
signal = "bullish"
elif total_score <= 5.5:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_possible_score,
"moat_analysis": moat_analysis,
"management_analysis": management_analysis,
"predictability_analysis": predictability_analysis,
"valuation_analysis": valuation_analysis,
# Include some qualitative assessment from news
"news_sentiment": analyze_news_sentiment(company_news) if company_news else "No news data available"
}
progress.update_status(agent_id, ticker, "Generating Charlie Munger analysis")
munger_output = generate_munger_output(
ticker=ticker,
analysis_data=analysis_data[ticker],
state=state,
agent_id=agent_id,
confidence_hint=compute_confidence(analysis_data[ticker], signal)
)
munger_analysis[ticker] = {
"signal": munger_output.signal,
"confidence": munger_output.confidence,
"reasoning": munger_output.reasoning
}
progress.update_status(agent_id, ticker, "Done", analysis=munger_output.reasoning)
# Wrap results in a single message for the chain
message = HumanMessage(
content=json.dumps(munger_analysis),
name=agent_id
)
# Show reasoning if requested
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(munger_analysis, "Charlie Munger Agent")
progress.update_status(agent_id, None, "Done")
# Add signals to the overall state
state["data"]["analyst_signals"][agent_id] = munger_analysis
return {
"messages": [message],
"data": state["data"]
}
def analyze_moat_strength(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {
"score": 0,
"details": "Insufficient data to analyze moat strength"
}
# 1. Return on Invested Capital (ROIC) analysis - Munger's favorite metric
roic_values = [item.return_on_invested_capital for item in financial_line_items
if hasattr(item, 'return_on_invested_capital') and item.return_on_invested_capital is not None]
if roic_values:
# Check if ROIC consistently above 15% (Munger's threshold)
high_roic_count = sum(1 for r in roic_values if r > 0.15)
if high_roic_count >= len(roic_values) * 0.8: # 80% of periods show high ROIC
score += 3
details.append(f"Excellent ROIC: >15% in {high_roic_count}/{len(roic_values)} periods")
elif high_roic_count >= len(roic_values) * 0.5: # 50% of periods
score += 2
details.append(f"Good ROIC: >15% in {high_roic_count}/{len(roic_values)} periods")
elif high_roic_count > 0:
score += 1
details.append(f"Mixed ROIC: >15% in only {high_roic_count}/{len(roic_values)} periods")
else:
details.append("Poor ROIC: Never exceeds 15% threshold")
else:
details.append("No ROIC data available")
# 2. Pricing power - check gross margin stability and trends
gross_margins = [item.gross_margin for item in financial_line_items
if hasattr(item, 'gross_margin') and item.gross_margin is not None]
if gross_margins and len(gross_margins) >= 3:
# Munger likes stable or improving gross margins
margin_trend = sum(1 for i in range(1, len(gross_margins)) if gross_margins[i] >= gross_margins[i-1])
if margin_trend >= len(gross_margins) * 0.7: # Improving in 70% of periods
score += 2
details.append("Strong pricing power: Gross margins consistently improving")
elif sum(gross_margins) / len(gross_margins) > 0.3: # Average margin > 30%
score += 1
details.append(f"Good pricing power: Average gross margin {sum(gross_margins)/len(gross_margins):.1%}")
else:
details.append("Limited pricing power: Low or declining gross margins")
else:
details.append("Insufficient gross margin data")
# 3. Capital intensity - Munger prefers low capex businesses
if len(financial_line_items) >= 3:
capex_to_revenue = []
for item in financial_line_items:
if (hasattr(item, 'capital_expenditure') and item.capital_expenditure is not None and
hasattr(item, 'revenue') and item.revenue is not None and item.revenue > 0):
# Note: capital_expenditure is typically negative in financial statements
capex_ratio = abs(item.capital_expenditure) / item.revenue
capex_to_revenue.append(capex_ratio)
if capex_to_revenue:
avg_capex_ratio = sum(capex_to_revenue) / len(capex_to_revenue)
if avg_capex_ratio < 0.05: # Less than 5% of revenue
score += 2
details.append(f"Low capital requirements: Avg capex {avg_capex_ratio:.1%} of revenue")
elif avg_capex_ratio < 0.10: # Less than 10% of revenue
score += 1
details.append(f"Moderate capital requirements: Avg capex {avg_capex_ratio:.1%} of revenue")
else:
details.append(f"High capital requirements: Avg capex {avg_capex_ratio:.1%} of revenue")
else:
details.append("No capital expenditure data available")
else:
details.append("Insufficient data for capital intensity analysis")
# 4. Intangible assets - Munger values R&D and intellectual property
r_and_d = [item.research_and_development for item in financial_line_items
if hasattr(item, 'research_and_development') and item.research_and_development is not None]
goodwill_and_intangible_assets = [item.goodwill_and_intangible_assets for item in financial_line_items
if hasattr(item, 'goodwill_and_intangible_assets') and item.goodwill_and_intangible_assets is not None]
if r_and_d and len(r_and_d) > 0:
if sum(r_and_d) > 0: # If company is investing in R&D
score += 1
details.append("Invests in R&D, building intellectual property")
if (goodwill_and_intangible_assets and len(goodwill_and_intangible_assets) > 0):
score += 1
details.append("Significant goodwill/intangible assets, suggesting brand value or IP")
# Scale score to 0-10 range
final_score = min(10, score * 10 / 9) # Max possible raw score is 9
return {
"score": final_score,
"details": "; ".join(details)
}
def analyze_management_quality(financial_line_items: list, insider_trades: list) -> dict:
score = 0
details = []
if not financial_line_items:
return {
"score": 0,
"details": "Insufficient data to analyze management quality"
}
# 1. Capital allocation - Check FCF to net income ratio
# Munger values companies that convert earnings to cash
fcf_values = [item.free_cash_flow for item in financial_line_items
if hasattr(item, 'free_cash_flow') and item.free_cash_flow is not None]
net_income_values = [item.net_income for item in financial_line_items
if hasattr(item, 'net_income') and item.net_income is not None]
if fcf_values and net_income_values and len(fcf_values) == len(net_income_values):
# Calculate FCF to Net Income ratio for each period
fcf_to_ni_ratios = []
for i in range(len(fcf_values)):
if net_income_values[i] and net_income_values[i] > 0:
fcf_to_ni_ratios.append(fcf_values[i] / net_income_values[i])
if fcf_to_ni_ratios:
avg_ratio = sum(fcf_to_ni_ratios) / len(fcf_to_ni_ratios)
if avg_ratio > 1.1: # FCF > net income suggests good accounting
score += 3
details.append(f"Excellent cash conversion: FCF/NI ratio of {avg_ratio:.2f}")
elif avg_ratio > 0.9: # FCF roughly equals net income
score += 2
details.append(f"Good cash conversion: FCF/NI ratio of {avg_ratio:.2f}")
elif avg_ratio > 0.7: # FCF somewhat lower than net income
score += 1
details.append(f"Moderate cash conversion: FCF/NI ratio of {avg_ratio:.2f}")
else:
details.append(f"Poor cash conversion: FCF/NI ratio of only {avg_ratio:.2f}")
else:
details.append("Could not calculate FCF to Net Income ratios")
else:
details.append("Missing FCF or Net Income data")
# 2. Debt management - Munger is cautious about debt
debt_values = [item.total_debt for item in financial_line_items
if hasattr(item, 'total_debt') and item.total_debt is not None]
equity_values = [item.shareholders_equity for item in financial_line_items
if hasattr(item, 'shareholders_equity') and item.shareholders_equity is not None]
if debt_values and equity_values and len(debt_values) == len(equity_values):
# Calculate D/E ratio for most recent period
recent_de_ratio = debt_values[0] / equity_values[0] if equity_values[0] > 0 else float('inf')
if recent_de_ratio < 0.3: # Very low debt
score += 3
details.append(f"Conservative debt management: D/E ratio of {recent_de_ratio:.2f}")
elif recent_de_ratio < 0.7: # Moderate debt
score += 2
details.append(f"Prudent debt management: D/E ratio of {recent_de_ratio:.2f}")
elif recent_de_ratio < 1.5: # Higher but still reasonable debt
score += 1
details.append(f"Moderate debt level: D/E ratio of {recent_de_ratio:.2f}")
else:
details.append(f"High debt level: D/E ratio of {recent_de_ratio:.2f}")
else:
details.append("Missing debt or equity data")
# 3. Cash management efficiency - Munger values appropriate cash levels
cash_values = [item.cash_and_equivalents for item in financial_line_items
if hasattr(item, 'cash_and_equivalents') and item.cash_and_equivalents is not None]
revenue_values = [item.revenue for item in financial_line_items
if hasattr(item, 'revenue') and item.revenue is not None]
if cash_values and revenue_values and len(cash_values) > 0 and len(revenue_values) > 0:
# Calculate cash to revenue ratio (Munger likes 10-20% for most businesses)
cash_to_revenue = cash_values[0] / revenue_values[0] if revenue_values[0] > 0 else 0
if 0.1 <= cash_to_revenue <= 0.25:
# Goldilocks zone - not too much, not too little
score += 2
details.append(f"Prudent cash management: Cash/Revenue ratio of {cash_to_revenue:.2f}")
elif 0.05 <= cash_to_revenue < 0.1 or 0.25 < cash_to_revenue <= 0.4:
# Reasonable but not ideal
score += 1
details.append(f"Acceptable cash position: Cash/Revenue ratio of {cash_to_revenue:.2f}")
elif cash_to_revenue > 0.4:
# Too much cash - potentially inefficient capital allocation
details.append(f"Excess cash reserves: Cash/Revenue ratio of {cash_to_revenue:.2f}")
else:
# Too little cash - potentially risky
details.append(f"Low cash reserves: Cash/Revenue ratio of {cash_to_revenue:.2f}")
else:
details.append("Insufficient cash or revenue data")
# 4. Insider activity - Munger values skin in the game
if insider_trades and len(insider_trades) > 0:
# Count buys vs. sells
buys = sum(1 for trade in insider_trades if hasattr(trade, 'transaction_type') and
trade.transaction_type and trade.transaction_type.lower() in ['buy', 'purchase'])
sells = sum(1 for trade in insider_trades if hasattr(trade, 'transaction_type') and
trade.transaction_type and trade.transaction_type.lower() in ['sell', 'sale'])
# Calculate the buy ratio
total_trades = buys + sells
if total_trades > 0:
buy_ratio = buys / total_trades
if buy_ratio > 0.7: # Strong insider buying
score += 2
details.append(f"Strong insider buying: {buys}/{total_trades} transactions are purchases")
elif buy_ratio > 0.4: # Balanced insider activity
score += 1
details.append(f"Balanced insider trading: {buys}/{total_trades} transactions are purchases")
elif buy_ratio < 0.1 and sells > 5: # Heavy selling
score -= 1 # Penalty for excessive selling
details.append(f"Concerning insider selling: {sells}/{total_trades} transactions are sales")
else:
details.append(f"Mixed insider activity: {buys}/{total_trades} transactions are purchases")
else:
details.append("No recorded insider transactions")
else:
details.append("No insider trading data available")
# 5. Consistency in share count - Munger prefers stable/decreasing shares
share_counts = [item.outstanding_shares for item in financial_line_items
if hasattr(item, 'outstanding_shares') and item.outstanding_shares is not None]
if share_counts and len(share_counts) >= 3:
if share_counts[0] < share_counts[-1] * 0.95: # 5%+ reduction in shares
score += 2
details.append("Shareholder-friendly: Reducing share count over time")
elif share_counts[0] < share_counts[-1] * 1.05: # Stable share count
score += 1
details.append("Stable share count: Limited dilution")
elif share_counts[0] > share_counts[-1] * 1.2: # >20% dilution
score -= 1 # Penalty for excessive dilution
details.append("Concerning dilution: Share count increased significantly")
else:
details.append("Moderate share count increase over time")
else:
details.append("Insufficient share count data")
# FCF / NI ratios -> already computed for scoring
insider_buy_ratio = None
recent_de_ratio = None
cash_to_revenue = None
share_count_trend = "unknown"
# Debt ratio (D/E) -> we compute `recent_de_ratio`
if debt_values and equity_values and len(debt_values) == len(equity_values):
recent_de_ratio = debt_values[0] / equity_values[0] if equity_values[0] > 0 else float("inf")
# Cash/Revenue -> we compute `cash_to_revenue`
if cash_values and revenue_values and revenue_values[0] and revenue_values[0] > 0:
cash_to_revenue = cash_values[0] / revenue_values[0]
# Insider ratio -> we compute `insider_buy_ratio`
if insider_trades and len(insider_trades) > 0:
buys = sum(1 for t in insider_trades
if getattr(t, "transaction_type", None)
and t.transaction_type.lower() in ["buy", "purchase"])
sells = sum(1 for t in insider_trades
if getattr(t, "transaction_type", None)
and t.transaction_type.lower() in ["sell", "sale"])
total = buys + sells
insider_buy_ratio = (buys / total) if total > 0 else None
# Share count trend (decreasing / stable / increasing)
share_counts = [item.outstanding_shares for item in financial_line_items
if hasattr(item, "outstanding_shares") and item.outstanding_shares is not None]
if share_counts and len(share_counts) >= 3:
if share_counts[0] < share_counts[-1] * 0.95:
share_count_trend = "decreasing"
elif share_counts[0] > share_counts[-1] * 1.05:
share_count_trend = "increasing"
else:
share_count_trend = "stable"
# Scale score to 0-10 range
# Maximum possible raw score would be 12 (3+3+2+2+2)
final_score = max(0, min(10, score * 10 / 12))
return {
"score": final_score,
"details": "; ".join(details),
"insider_buy_ratio": insider_buy_ratio,
"recent_de_ratio": recent_de_ratio,
"cash_to_revenue": cash_to_revenue,
"share_count_trend": share_count_trend,
}
def analyze_predictability(financial_line_items: list) -> dict:
score = 0
details = []
if not financial_line_items or len(financial_line_items) < 5:
return {
"score": 0,
"details": "Insufficient data to analyze business predictability (need 5+ years)"
}
# 1. Revenue stability and growth
revenues = [item.revenue for item in financial_line_items
if hasattr(item, 'revenue') and item.revenue is not None]
if revenues and len(revenues) >= 5:
# Calculate year-over-year growth rates, handling zero division
growth_rates = []
for i in range(len(revenues)-1):
if revenues[i+1] != 0: # Avoid division by zero
growth_rate = (revenues[i] / revenues[i+1] - 1)
growth_rates.append(growth_rate)
if not growth_rates:
details.append("Cannot calculate revenue growth: zero revenue values found")
else:
avg_growth = sum(growth_rates) / len(growth_rates)
growth_volatility = sum(abs(r - avg_growth) for r in growth_rates) / len(growth_rates)
if avg_growth > 0.05 and growth_volatility < 0.1:
# Steady, consistent growth (Munger loves this)
score += 3
details.append(f"Highly predictable revenue: {avg_growth:.1%} avg growth with low volatility")
elif avg_growth > 0 and growth_volatility < 0.2:
# Positive but somewhat volatile growth
score += 2
details.append(f"Moderately predictable revenue: {avg_growth:.1%} avg growth with some volatility")
elif avg_growth > 0:
# Growing but unpredictable
score += 1
details.append(f"Growing but less predictable revenue: {avg_growth:.1%} avg growth with high volatility")
else:
details.append(f"Declining or highly unpredictable revenue: {avg_growth:.1%} avg growth")
else:
details.append("Insufficient revenue history for predictability analysis")
# 2. Operating income stability
op_income = [item.operating_income for item in financial_line_items
if hasattr(item, 'operating_income') and item.operating_income is not None]
if op_income and len(op_income) >= 5:
# Count positive operating income periods
positive_periods = sum(1 for income in op_income if income > 0)
if positive_periods == len(op_income):
# Consistently profitable operations
score += 3
details.append("Highly predictable operations: Operating income positive in all periods")
elif positive_periods >= len(op_income) * 0.8:
# Mostly profitable operations
score += 2
details.append(f"Predictable operations: Operating income positive in {positive_periods}/{len(op_income)} periods")
elif positive_periods >= len(op_income) * 0.6:
# Somewhat profitable operations
score += 1
details.append(f"Somewhat predictable operations: Operating income positive in {positive_periods}/{len(op_income)} periods")
else:
details.append(f"Unpredictable operations: Operating income positive in only {positive_periods}/{len(op_income)} periods")
else:
details.append("Insufficient operating income history")
# 3. Margin consistency - Munger values stable margins
op_margins = [item.operating_margin for item in financial_line_items
if hasattr(item, 'operating_margin') and item.operating_margin is not None]
if op_margins and len(op_margins) >= 5:
# Calculate margin volatility
avg_margin = sum(op_margins) / len(op_margins)
margin_volatility = sum(abs(m - avg_margin) for m in op_margins) / len(op_margins)
if margin_volatility < 0.03: # Very stable margins
score += 2
details.append(f"Highly predictable margins: {avg_margin:.1%} avg with minimal volatility")
elif margin_volatility < 0.07: # Moderately stable margins
score += 1
details.append(f"Moderately predictable margins: {avg_margin:.1%} avg with some volatility")
else:
details.append(f"Unpredictable margins: {avg_margin:.1%} avg with high volatility ({margin_volatility:.1%})")
else:
details.append("Insufficient margin history")
# 4. Cash generation reliability
fcf_values = [item.free_cash_flow for item in financial_line_items
if hasattr(item, 'free_cash_flow') and item.free_cash_flow is not None]
if fcf_values and len(fcf_values) >= 5:
# Count positive FCF periods
positive_fcf_periods = sum(1 for fcf in fcf_values if fcf > 0)
if positive_fcf_periods == len(fcf_values):
# Consistently positive FCF
score += 2
details.append("Highly predictable cash generation: Positive FCF in all periods")
elif positive_fcf_periods >= len(fcf_values) * 0.8:
# Mostly positive FCF
score += 1
details.append(f"Predictable cash generation: Positive FCF in {positive_fcf_periods}/{len(fcf_values)} periods")
else:
details.append(f"Unpredictable cash generation: Positive FCF in only {positive_fcf_periods}/{len(fcf_values)} periods")
else:
details.append("Insufficient free cash flow history")
# Scale score to 0-10 range
# Maximum possible raw score would be 10 (3+3+2+2)
final_score = min(10, score * 10 / 10)
return {
"score": final_score,
"details": "; ".join(details)
}
def calculate_munger_valuation(financial_line_items: list, market_cap: float) -> dict:
score = 0
details = []
if not financial_line_items or market_cap is None:
return {
"score": 0,
"details": "Insufficient data to perform valuation"
}
# Get FCF values (Munger's preferred "owner earnings" metric)
fcf_values = [item.free_cash_flow for item in financial_line_items
if hasattr(item, 'free_cash_flow') and item.free_cash_flow is not None]
if not fcf_values or len(fcf_values) < 3:
return {
"score": 0,
"details": "Insufficient free cash flow data for valuation"
}
# 1. Normalize earnings by taking average of last 3-5 years
# (Munger prefers to normalize earnings to avoid over/under-valuation based on cyclical factors)
normalized_fcf = sum(fcf_values[:min(5, len(fcf_values))]) / min(5, len(fcf_values))
if normalized_fcf <= 0:
return {
"score": 0,
"details": f"Negative or zero normalized FCF ({normalized_fcf}), cannot value",
"intrinsic_value": None
}
# 2. Calculate FCF yield (inverse of P/FCF multiple)
if market_cap <= 0:
return {
"score": 0,
"details": f"Invalid market cap ({market_cap}), cannot value"
}
fcf_yield = normalized_fcf / market_cap
# 3. Apply Munger's FCF multiple based on business quality
# Munger would pay higher multiples for wonderful businesses
# Let's use a sliding scale where higher FCF yields are more attractive
if fcf_yield > 0.08: # >8% FCF yield (P/FCF < 12.5x)
score += 4
details.append(f"Excellent value: {fcf_yield:.1%} FCF yield")
elif fcf_yield > 0.05: # >5% FCF yield (P/FCF < 20x)
score += 3
details.append(f"Good value: {fcf_yield:.1%} FCF yield")
elif fcf_yield > 0.03: # >3% FCF yield (P/FCF < 33x)
score += 1
details.append(f"Fair value: {fcf_yield:.1%} FCF yield")
else:
details.append(f"Expensive: Only {fcf_yield:.1%} FCF yield")
# 4. Calculate simple intrinsic value range
# Munger tends to use straightforward valuations, avoiding complex DCF models
conservative_value = normalized_fcf * 10 # 10x FCF = 10% yield
reasonable_value = normalized_fcf * 15 # 15x FCF ≈ 6.7% yield
optimistic_value = normalized_fcf * 20 # 20x FCF = 5% yield
# 5. Calculate margins of safety
margin_of_safety_vs_fair_value = (reasonable_value - market_cap) / market_cap
if margin_of_safety_vs_fair_value > 0.3: # >30% upside
score += 3
details.append(f"Large margin of safety: {margin_of_safety_vs_fair_value:.1%} upside to reasonable value")
elif margin_of_safety_vs_fair_value > 0.1: # >10% upside
score += 2
details.append(f"Moderate margin of safety: {margin_of_safety_vs_fair_value:.1%} upside to reasonable value")
elif margin_of_safety_vs_fair_value > -0.1: # Within 10% of reasonable value
score += 1
details.append(f"Fair price: Within 10% of reasonable value ({margin_of_safety_vs_fair_value:.1%})")
else:
details.append(f"Expensive: {-margin_of_safety_vs_fair_value:.1%} premium to reasonable value")
# 6. Check earnings trajectory for additional context
# Munger likes growing owner earnings
if len(fcf_values) >= 3:
recent_avg = sum(fcf_values[:3]) / 3
older_avg = sum(fcf_values[-3:]) / 3 if len(fcf_values) >= 6 else fcf_values[-1]
if recent_avg > older_avg * 1.2: # >20% growth in FCF
score += 3
details.append("Growing FCF trend adds to intrinsic value")
elif recent_avg > older_avg:
score += 2
details.append("Stable to growing FCF supports valuation")
else:
details.append("Declining FCF trend is concerning")
# Scale score to 0-10 range
# Maximum possible raw score would be 10 (4+3+3)
final_score = min(10, score * 10 / 10)
return {
"score": final_score,
"details": "; ".join(details),
"intrinsic_value_range": {
"conservative": conservative_value,
"reasonable": reasonable_value,
"optimistic": optimistic_value
},
"fcf_yield": fcf_yield,
"normalized_fcf": normalized_fcf,
"margin_of_safety_vs_fair_value": margin_of_safety_vs_fair_value,
}
def analyze_news_sentiment(news_items: list) -> str:
if not news_items or len(news_items) == 0:
return "No news data available"
# Just return a simple count for now - in a real implementation, this would use NLP
return f"Qualitative review of {len(news_items)} recent news items would be needed"
def _r(x, n=3):
try:
return round(float(x), n)
except Exception:
return None
def make_munger_facts_bundle(analysis: dict[str, any]) -> dict[str, any]:
moat = analysis.get("moat_analysis") or {}
mgmt = analysis.get("management_analysis") or {}
pred = analysis.get("predictability_analysis") or {}
val = analysis.get("valuation_analysis") or {}
ivr = val.get("intrinsic_value_range") or {}
moat_score = _r(moat.get("score"), 2) or 0
mgmt_score = _r(mgmt.get("score"), 2) or 0
pred_score = _r(pred.get("score"), 2) or 0
val_score = _r(val.get("score"), 2) or 0
# Simple mental-model flags (booleans/ints = cheap tokens, strong guidance)
flags = {
"moat_strong": moat_score >= 7,
"predictable": pred_score >= 7,
"owner_aligned": (mgmt_score >= 7) or ((mgmt.get("insider_buy_ratio") or 0) >= 0.6),
"low_leverage": (mgmt.get("recent_de_ratio") is not None and mgmt.get("recent_de_ratio") < 0.7),
"sensible_cash": (mgmt.get("cash_to_revenue") is not None and 0.1 <= mgmt.get("cash_to_revenue") <= 0.25),
"low_capex": None, # inferred in moat score already; keep placeholder if you later expose a ratio
"mos_positive": (val.get("mos_to_reasonable") or 0) > 0.0,
"fcf_yield_ok": (val.get("fcf_yield") or 0) >= 0.05,
"share_count_friendly": (mgmt.get("share_count_trend") == "decreasing"),
}
return {
"pre_signal": analysis.get("signal"),
"score": _r(analysis.get("score"), 2),
"max_score": _r(analysis.get("max_score"), 2),
"moat_score": moat_score,
"mgmt_score": mgmt_score,
"predictability_score": pred_score,
"valuation_score": val_score,
"fcf_yield": _r(val.get("fcf_yield"), 4),
"normalized_fcf": _r(val.get("normalized_fcf"), 0),
"reasonable_value": _r(ivr.get("reasonable"), 0),
"margin_of_safety_vs_fair_value": _r(val.get("margin_of_safety_vs_fair_value"), 3),
"insider_buy_ratio": _r(mgmt.get("insider_buy_ratio"), 2),
"recent_de_ratio": _r(mgmt.get("recent_de_ratio"), 2),
"cash_to_revenue": _r(mgmt.get("cash_to_revenue"), 2),
"share_count_trend": mgmt.get("share_count_trend"),
"flags": flags,
# keep one-liners, very short
"notes": {
"moat": (moat.get("details") or "")[:120],
"mgmt": (mgmt.get("details") or "")[:120],
"predictability": (pred.get("details") or "")[:120],
"valuation": (val.get("details") or "")[:120],
},
}
def compute_confidence(analysis: dict, signal: str) -> int:
# Pull component scores (0..10 each in your pipeline)
moat = float((analysis.get("moat_analysis") or {}).get("score") or 0)
mgmt = float((analysis.get("management_analysis") or {}).get("score") or 0)
pred = float((analysis.get("predictability_analysis") or {}).get("score") or 0)
val = float((analysis.get("valuation_analysis") or {}).get("score") or 0)
# Quality dominates (Munger): 0.35*moat + 0.25*mgmt + 0.25*pred (max 8.5)
quality = 0.35 * moat + 0.25 * mgmt + 0.25 * pred # 0..8.5
quality_pct = 100 * (quality / 8.5) if quality > 0 else 0 # 0..100
# Valuation bump from MOS vs “reasonable”
mos = (analysis.get("valuation_analysis") or {}).get("margin_of_safety_vs_fair_value")
mos = float(mos) if mos is not None else 0.0
# Convert MOS into a bounded +/-10pp adjustment
val_adj = max(-10.0, min(10.0, mos * 100.0 / 3.0)) # ~+/-10pp if MOS is around +/-30%
# Base confidence: weighted toward quality, then small valuation adjustment
base = 0.85 * quality_pct + 0.15 * (val * 10) # val score 0..10 -> 0..100
base = base + val_adj
# Ensure bucket semantics by clamping into Munger buckets depending on signal
if signal == "bullish":
# If overvalued (mos<0), cap to mixed bucket
upper = 100 if mos > 0 else 69
lower = 50 if quality_pct >= 55 else 30
elif signal == "bearish":
# If clearly overvalued (mos< -0.05), allow very low bucket
lower = 10 if mos < -0.05 else 30
upper = 49
else: # neutral
lower, upper = 50, 69
conf = int(round(max(lower, min(upper, base))))
# Keep inside global 10..100
return max(10, min(100, conf))
def generate_munger_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
confidence_hint: int,
) -> CharlieMungerSignal:
facts_bundle = make_munger_facts_bundle(analysis_data)
template = ChatPromptTemplate.from_messages([
("system",
"You are Charlie Munger. Decide bullish, bearish, or neutral using only the facts. "
"Return JSON only. Keep reasoning under 120 characters. "
"Use the provided confidence exactly; do not change it."),
("human",
"Ticker: {ticker}\n"
"Facts:\n{facts}\n"
"Confidence: {confidence}\n"
"Return exactly:\n"
"{{\n" # escaped {
' "signal": "bullish" | "bearish" | "neutral",\n'
f' "confidence": {confidence_hint},\n'
' "reasoning": "short justification"\n'
"}}") # escaped }
])
prompt = template.invoke({
"ticker": ticker,
"facts": json.dumps(facts_bundle, separators=(",", ":"), ensure_ascii=False),
"confidence": confidence_hint,
})
def _default():
return CharlieMungerSignal(signal="neutral", confidence=confidence_hint, reasoning="Insufficient data")
return call_llm(
prompt=prompt,
pydantic_model=CharlieMungerSignal,
agent_name=agent_id,
state=state,
default_factory=_default,
) | --- +++ @@ -16,6 +16,10 @@
def charlie_munger_agent(state: AgentState, agent_id: str = "charlie_munger_agent"):
+ """
+ Analyzes stocks using Charlie Munger's investing principles and mental models.
+ Focuses on moat strength, management quality, predictability, and valuation.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -155,6 +159,13 @@
def analyze_moat_strength(metrics: list, financial_line_items: list) -> dict:
+ """
+ Analyze the business's competitive advantage using Munger's approach:
+ - Consistent high returns on capital (ROIC)
+ - Pricing power (stable/improving gross margins)
+ - Low capital requirements
+ - Network effects and intangible assets (R&D investments, goodwill)
+ """
score = 0
details = []
@@ -255,6 +266,14 @@
def analyze_management_quality(financial_line_items: list, insider_trades: list) -> dict:
+ """
+ Evaluate management quality using Munger's criteria:
+ - Capital allocation wisdom
+ - Insider ownership and transactions
+ - Cash management efficiency
+ - Candor and transparency
+ - Long-term focus
+ """
score = 0
details = []
@@ -448,6 +467,10 @@
def analyze_predictability(financial_line_items: list) -> dict:
+ """
+ Assess the predictability of the business - Munger strongly prefers businesses
+ whose future operations and cashflows are relatively easy to predict.
+ """
score = 0
details = []
@@ -569,6 +592,12 @@
def calculate_munger_valuation(financial_line_items: list, market_cap: float) -> dict:
+ """
+ Calculate intrinsic value using Munger's approach:
+ - Focus on owner earnings (approximated by FCF)
+ - Simple multiple on normalized earnings
+ - Prefer paying a fair price for a wonderful business
+ """
score = 0
details = []
@@ -679,6 +708,10 @@
def analyze_news_sentiment(news_items: list) -> str:
+ """
+ Simple qualitative analysis of recent news.
+ Munger pays attention to significant news but doesn't overreact to short-term stories.
+ """
if not news_items or len(news_items) == 0:
return "No news data available"
@@ -820,4 +853,4 @@ agent_name=agent_id,
state=state,
default_factory=_default,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/charlie_munger.py |
Write docstrings describing functionality | from __future__ import annotations
import json
from typing_extensions import Literal
from pydantic import BaseModel
from src.graph.state import AgentState, show_agent_reasoning
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from src.tools.api import (
get_financial_metrics,
get_market_cap,
search_line_items,
)
from src.utils.api_key import get_api_key_from_state
from src.utils.llm import call_llm
from src.utils.progress import progress
class AswathDamodaranSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float # 0‒100
reasoning: str
def aswath_damodaran_agent(state: AgentState, agent_id: str = "aswath_damodaran_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data: dict[str, dict] = {}
damodaran_signals: dict[str, dict] = {}
for ticker in tickers:
# ─── Fetch core data ────────────────────────────────────────────────────
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="ttm", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching financial line items")
line_items = search_line_items(
ticker,
[
"free_cash_flow",
"ebit",
"interest_expense",
"capital_expenditure",
"depreciation_and_amortization",
"outstanding_shares",
"net_income",
"total_debt",
],
end_date,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
# ─── Analyses ───────────────────────────────────────────────────────────
progress.update_status(agent_id, ticker, "Analyzing growth and reinvestment")
growth_analysis = analyze_growth_and_reinvestment(metrics, line_items)
progress.update_status(agent_id, ticker, "Analyzing risk profile")
risk_analysis = analyze_risk_profile(metrics, line_items)
progress.update_status(agent_id, ticker, "Calculating intrinsic value (DCF)")
intrinsic_val_analysis = calculate_intrinsic_value_dcf(metrics, line_items, risk_analysis)
progress.update_status(agent_id, ticker, "Assessing relative valuation")
relative_val_analysis = analyze_relative_valuation(metrics)
# ─── Score & margin of safety ──────────────────────────────────────────
total_score = (
growth_analysis["score"]
+ risk_analysis["score"]
+ relative_val_analysis["score"]
)
max_score = growth_analysis["max_score"] + risk_analysis["max_score"] + relative_val_analysis["max_score"]
intrinsic_value = intrinsic_val_analysis["intrinsic_value"]
margin_of_safety = (
(intrinsic_value - market_cap) / market_cap if intrinsic_value and market_cap else None
)
# Decision rules (Damodaran tends to act with ~20-25 % MOS)
if margin_of_safety is not None and margin_of_safety >= 0.25:
signal = "bullish"
elif margin_of_safety is not None and margin_of_safety <= -0.25:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_score,
"margin_of_safety": margin_of_safety,
"growth_analysis": growth_analysis,
"risk_analysis": risk_analysis,
"relative_val_analysis": relative_val_analysis,
"intrinsic_val_analysis": intrinsic_val_analysis,
"market_cap": market_cap,
}
# ─── LLM: craft Damodaran-style narrative ──────────────────────────────
progress.update_status(agent_id, ticker, "Generating Damodaran analysis")
damodaran_output = generate_damodaran_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
damodaran_signals[ticker] = damodaran_output.model_dump()
progress.update_status(agent_id, ticker, "Done", analysis=damodaran_output.reasoning)
# ─── Push message back to graph state ──────────────────────────────────────
message = HumanMessage(content=json.dumps(damodaran_signals), name=agent_id)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(damodaran_signals, "Aswath Damodaran Agent")
state["data"]["analyst_signals"][agent_id] = damodaran_signals
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
# ────────────────────────────────────────────────────────────────────────────────
# Helper analyses
# ────────────────────────────────────────────────────────────────────────────────
def analyze_growth_and_reinvestment(metrics: list, line_items: list) -> dict[str, any]:
max_score = 4
if len(metrics) < 2:
return {"score": 0, "max_score": max_score, "details": "Insufficient history"}
# Revenue CAGR (oldest to latest)
revs = [m.revenue for m in reversed(metrics) if hasattr(m, "revenue") and m.revenue]
if len(revs) >= 2 and revs[0] > 0:
cagr = (revs[-1] / revs[0]) ** (1 / (len(revs) - 1)) - 1
else:
cagr = None
score, details = 0, []
if cagr is not None:
if cagr > 0.08:
score += 2
details.append(f"Revenue CAGR {cagr:.1%} (> 8 %)")
elif cagr > 0.03:
score += 1
details.append(f"Revenue CAGR {cagr:.1%} (> 3 %)")
else:
details.append(f"Sluggish revenue CAGR {cagr:.1%}")
else:
details.append("Revenue data incomplete")
# FCFF growth (proxy: free_cash_flow trend)
fcfs = [li.free_cash_flow for li in reversed(line_items) if li.free_cash_flow]
if len(fcfs) >= 2 and fcfs[-1] > fcfs[0]:
score += 1
details.append("Positive FCFF growth")
else:
details.append("Flat or declining FCFF")
# Reinvestment efficiency (ROIC vs. 10 % hurdle)
latest = metrics[0]
if latest.return_on_invested_capital and latest.return_on_invested_capital > 0.10:
score += 1
details.append(f"ROIC {latest.return_on_invested_capital:.1%} (> 10 %)")
return {"score": score, "max_score": max_score, "details": "; ".join(details), "metrics": latest.model_dump()}
def analyze_risk_profile(metrics: list, line_items: list) -> dict[str, any]:
max_score = 3
if not metrics:
return {"score": 0, "max_score": max_score, "details": "No metrics"}
latest = metrics[0]
score, details = 0, []
# Beta
beta = getattr(latest, "beta", None)
if beta is not None:
if beta < 1.3:
score += 1
details.append(f"Beta {beta:.2f}")
else:
details.append(f"High beta {beta:.2f}")
else:
details.append("Beta NA")
# Debt / Equity
dte = getattr(latest, "debt_to_equity", None)
if dte is not None:
if dte < 1:
score += 1
details.append(f"D/E {dte:.1f}")
else:
details.append(f"High D/E {dte:.1f}")
else:
details.append("D/E NA")
# Interest coverage
ebit = getattr(latest, "ebit", None)
interest = getattr(latest, "interest_expense", None)
if ebit and interest and interest != 0:
coverage = ebit / abs(interest)
if coverage > 3:
score += 1
details.append(f"Interest coverage × {coverage:.1f}")
else:
details.append(f"Weak coverage × {coverage:.1f}")
else:
details.append("Interest coverage NA")
# Compute cost of equity for later use
cost_of_equity = estimate_cost_of_equity(beta)
return {
"score": score,
"max_score": max_score,
"details": "; ".join(details),
"beta": beta,
"cost_of_equity": cost_of_equity,
}
def analyze_relative_valuation(metrics: list) -> dict[str, any]:
max_score = 1
if not metrics or len(metrics) < 5:
return {"score": 0, "max_score": max_score, "details": "Insufficient P/E history"}
pes = [m.price_to_earnings_ratio for m in metrics if m.price_to_earnings_ratio]
if len(pes) < 5:
return {"score": 0, "max_score": max_score, "details": "P/E data sparse"}
ttm_pe = pes[0]
median_pe = sorted(pes)[len(pes) // 2]
if ttm_pe < 0.7 * median_pe:
score, desc = 1, f"P/E {ttm_pe:.1f} vs. median {median_pe:.1f} (cheap)"
elif ttm_pe > 1.3 * median_pe:
score, desc = -1, f"P/E {ttm_pe:.1f} vs. median {median_pe:.1f} (expensive)"
else:
score, desc = 0, f"P/E inline with history"
return {"score": score, "max_score": max_score, "details": desc}
# ────────────────────────────────────────────────────────────────────────────────
# Intrinsic value via FCFF DCF (Damodaran style)
# ────────────────────────────────────────────────────────────────────────────────
def calculate_intrinsic_value_dcf(metrics: list, line_items: list, risk_analysis: dict) -> dict[str, any]:
if not metrics or len(metrics) < 2 or not line_items:
return {"intrinsic_value": None, "details": ["Insufficient data"]}
latest_m = metrics[0]
fcff0 = getattr(latest_m, "free_cash_flow", None)
shares = getattr(line_items[0], "outstanding_shares", None)
if not fcff0 or not shares:
return {"intrinsic_value": None, "details": ["Missing FCFF or share count"]}
# Growth assumptions
revs = [m.revenue for m in reversed(metrics) if m.revenue]
if len(revs) >= 2 and revs[0] > 0:
base_growth = min((revs[-1] / revs[0]) ** (1 / (len(revs) - 1)) - 1, 0.12)
else:
base_growth = 0.04 # fallback
terminal_growth = 0.025
years = 10
# Discount rate
discount = risk_analysis.get("cost_of_equity") or 0.09
# Project FCFF and discount
pv_sum = 0.0
g = base_growth
g_step = (terminal_growth - base_growth) / (years - 1)
for yr in range(1, years + 1):
fcff_t = fcff0 * (1 + g)
pv = fcff_t / (1 + discount) ** yr
pv_sum += pv
g += g_step
# Terminal value (perpetuity with terminal growth)
tv = (
fcff0
* (1 + terminal_growth)
/ (discount - terminal_growth)
/ (1 + discount) ** years
)
equity_value = pv_sum + tv
intrinsic_per_share = equity_value / shares
return {
"intrinsic_value": equity_value,
"intrinsic_per_share": intrinsic_per_share,
"assumptions": {
"base_fcff": fcff0,
"base_growth": base_growth,
"terminal_growth": terminal_growth,
"discount_rate": discount,
"projection_years": years,
},
"details": ["FCFF DCF completed"],
}
def estimate_cost_of_equity(beta: float | None) -> float:
risk_free = 0.04 # 10-yr US Treasury proxy
erp = 0.05 # long-run US equity risk premium
beta = beta if beta is not None else 1.0
return risk_free + beta * erp
# ────────────────────────────────────────────────────────────────────────────────
# LLM generation
# ────────────────────────────────────────────────────────────────────────────────
def generate_damodaran_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> AswathDamodaranSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are Aswath Damodaran, Professor of Finance at NYU Stern.
Use your valuation framework to issue trading signals on US equities.
Speak with your usual clear, data-driven tone:
◦ Start with the company "story" (qualitatively)
◦ Connect that story to key numerical drivers: revenue growth, margins, reinvestment, risk
◦ Conclude with value: your FCFF DCF estimate, margin of safety, and relative valuation sanity checks
◦ Highlight major uncertainties and how they affect value
Return ONLY the JSON specified below.""",
),
(
"human",
"""Ticker: {ticker}
Analysis data:
{analysis_data}
Respond EXACTLY in this JSON schema:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": float (0-100),
"reasoning": "string"
}}""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def default_signal():
return AswathDamodaranSignal(
signal="neutral",
confidence=0.0,
reasoning="Parsing error; defaulting to neutral",
)
return call_llm(
prompt=prompt,
pydantic_model=AswathDamodaranSignal,
agent_name=agent_id,
state=state,
default_factory=default_signal,
) | --- +++ @@ -25,6 +25,14 @@
def aswath_damodaran_agent(state: AgentState, agent_id: str = "aswath_damodaran_agent"):
+ """
+ Analyze US equities through Aswath Damodaran's intrinsic-value lens:
+ • Cost of Equity via CAPM (risk-free + β·ERP)
+ • 5-yr revenue / FCFF growth trends & reinvestment efficiency
+ • FCFF-to-Firm DCF → equity value → per-share intrinsic value
+ • Cross-check with relative valuation (PE vs. Fwd PE sector median proxy)
+ Produces a trading signal and explanation in Damodaran's analytical voice.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -133,6 +141,13 @@ # Helper analyses
# ────────────────────────────────────────────────────────────────────────────────
def analyze_growth_and_reinvestment(metrics: list, line_items: list) -> dict[str, any]:
+ """
+ Growth score (0-4):
+ +2 5-yr CAGR of revenue > 8 %
+ +1 5-yr CAGR of revenue > 3 %
+ +1 Positive FCFF growth over 5 yr
+ Reinvestment efficiency (ROIC > WACC) adds +1
+ """
max_score = 4
if len(metrics) < 2:
return {"score": 0, "max_score": max_score, "details": "Insufficient history"}
@@ -176,6 +191,12 @@
def analyze_risk_profile(metrics: list, line_items: list) -> dict[str, any]:
+ """
+ Risk score (0-3):
+ +1 Beta < 1.3
+ +1 Debt/Equity < 1
+ +1 Interest Coverage > 3×
+ """
max_score = 3
if not metrics:
return {"score": 0, "max_score": max_score, "details": "No metrics"}
@@ -231,6 +252,12 @@
def analyze_relative_valuation(metrics: list) -> dict[str, any]:
+ """
+ Simple PE check vs. historical median (proxy since sector comps unavailable):
+ +1 if TTM P/E < 70 % of 5-yr median
+ +0 if between 70 %-130 %
+ ‑1 if >130 %
+ """
max_score = 1
if not metrics or len(metrics) < 5:
return {"score": 0, "max_score": max_score, "details": "Insufficient P/E history"}
@@ -256,6 +283,13 @@ # Intrinsic value via FCFF DCF (Damodaran style)
# ────────────────────────────────────────────────────────────────────────────────
def calculate_intrinsic_value_dcf(metrics: list, line_items: list, risk_analysis: dict) -> dict[str, any]:
+ """
+ FCFF DCF with:
+ • Base FCFF = latest free cash flow
+ • Growth = 5-yr revenue CAGR (capped 12 %)
+ • Fade linearly to terminal growth 2.5 % by year 10
+ • Discount @ cost of equity (no debt split given data limitations)
+ """
if not metrics or len(metrics) < 2 or not line_items:
return {"intrinsic_value": None, "details": ["Insufficient data"]}
@@ -314,6 +348,7 @@
def estimate_cost_of_equity(beta: float | None) -> float:
+ """CAPM: r_e = r_f + β × ERP (use Damodaran's long-term averages)."""
risk_free = 0.04 # 10-yr US Treasury proxy
erp = 0.05 # long-run US equity risk premium
beta = beta if beta is not None else 1.0
@@ -329,6 +364,12 @@ state: AgentState,
agent_id: str,
) -> AswathDamodaranSignal:
+ """
+ Ask the LLM to channel Prof. Damodaran's analytical style:
+ • Story → Numbers → Value narrative
+ • Emphasize risk, growth, and cash-flow assumptions
+ • Cite cost of capital, implied MOS, and valuation cross-checks
+ """
template = ChatPromptTemplate.from_messages(
[
(
@@ -375,4 +416,4 @@ agent_name=agent_id,
state=state,
default_factory=default_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/aswath_damodaran.py |
Fully document this Python code with docstrings | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
import math
from src.utils.api_key import get_api_key_from_state
class BenGrahamSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def ben_graham_agent(state: AgentState, agent_id: str = "ben_graham_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
graham_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
financial_line_items = search_line_items(ticker, ["earnings_per_share", "revenue", "net_income", "book_value_per_share", "total_assets", "total_liabilities", "current_assets", "current_liabilities", "dividends_and_other_cash_distributions", "outstanding_shares"], end_date, period="annual", limit=10, api_key=api_key)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
# Perform sub-analyses
progress.update_status(agent_id, ticker, "Analyzing earnings stability")
earnings_analysis = analyze_earnings_stability(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing financial strength")
strength_analysis = analyze_financial_strength(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing Graham valuation")
valuation_analysis = analyze_valuation_graham(financial_line_items, market_cap)
# Aggregate scoring
total_score = earnings_analysis["score"] + strength_analysis["score"] + valuation_analysis["score"]
max_possible_score = 15 # total possible from the three analysis functions
# Map total_score to signal
if total_score >= 0.7 * max_possible_score:
signal = "bullish"
elif total_score <= 0.3 * max_possible_score:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {"signal": signal, "score": total_score, "max_score": max_possible_score, "earnings_analysis": earnings_analysis, "strength_analysis": strength_analysis, "valuation_analysis": valuation_analysis}
progress.update_status(agent_id, ticker, "Generating Ben Graham analysis")
graham_output = generate_graham_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
graham_analysis[ticker] = {"signal": graham_output.signal, "confidence": graham_output.confidence, "reasoning": graham_output.reasoning}
progress.update_status(agent_id, ticker, "Done", analysis=graham_output.reasoning)
# Wrap results in a single message for the chain
message = HumanMessage(content=json.dumps(graham_analysis), name=agent_id)
# Optionally display reasoning
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(graham_analysis, "Ben Graham Agent")
# Store signals in the overall state
state["data"]["analyst_signals"][agent_id] = graham_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_earnings_stability(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {"score": score, "details": "Insufficient data for earnings stability analysis"}
eps_vals = []
for item in financial_line_items:
if item.earnings_per_share is not None:
eps_vals.append(item.earnings_per_share)
if len(eps_vals) < 2:
details.append("Not enough multi-year EPS data.")
return {"score": score, "details": "; ".join(details)}
# 1. Consistently positive EPS
positive_eps_years = sum(1 for e in eps_vals if e > 0)
total_eps_years = len(eps_vals)
if positive_eps_years == total_eps_years:
score += 3
details.append("EPS was positive in all available periods.")
elif positive_eps_years >= (total_eps_years * 0.8):
score += 2
details.append("EPS was positive in most periods.")
else:
details.append("EPS was negative in multiple periods.")
# 2. EPS growth from earliest to latest
if eps_vals[0] > eps_vals[-1]:
score += 1
details.append("EPS grew from earliest to latest period.")
else:
details.append("EPS did not grow from earliest to latest period.")
return {"score": score, "details": "; ".join(details)}
def analyze_financial_strength(financial_line_items: list) -> dict:
score = 0
details = []
if not financial_line_items:
return {"score": score, "details": "No data for financial strength analysis"}
latest_item = financial_line_items[0]
total_assets = latest_item.total_assets or 0
total_liabilities = latest_item.total_liabilities or 0
current_assets = latest_item.current_assets or 0
current_liabilities = latest_item.current_liabilities or 0
# 1. Current ratio
if current_liabilities > 0:
current_ratio = current_assets / current_liabilities
if current_ratio >= 2.0:
score += 2
details.append(f"Current ratio = {current_ratio:.2f} (>=2.0: solid).")
elif current_ratio >= 1.5:
score += 1
details.append(f"Current ratio = {current_ratio:.2f} (moderately strong).")
else:
details.append(f"Current ratio = {current_ratio:.2f} (<1.5: weaker liquidity).")
else:
details.append("Cannot compute current ratio (missing or zero current_liabilities).")
# 2. Debt vs. Assets
if total_assets > 0:
debt_ratio = total_liabilities / total_assets
if debt_ratio < 0.5:
score += 2
details.append(f"Debt ratio = {debt_ratio:.2f}, under 0.50 (conservative).")
elif debt_ratio < 0.8:
score += 1
details.append(f"Debt ratio = {debt_ratio:.2f}, somewhat high but could be acceptable.")
else:
details.append(f"Debt ratio = {debt_ratio:.2f}, quite high by Graham standards.")
else:
details.append("Cannot compute debt ratio (missing total_assets).")
# 3. Dividend track record
div_periods = [item.dividends_and_other_cash_distributions for item in financial_line_items if item.dividends_and_other_cash_distributions is not None]
if div_periods:
# In many data feeds, dividend outflow is shown as a negative number
# (money going out to shareholders). We'll consider any negative as 'paid a dividend'.
div_paid_years = sum(1 for d in div_periods if d < 0)
if div_paid_years > 0:
# e.g. if at least half the periods had dividends
if div_paid_years >= (len(div_periods) // 2 + 1):
score += 1
details.append("Company paid dividends in the majority of the reported years.")
else:
details.append("Company has some dividend payments, but not most years.")
else:
details.append("Company did not pay dividends in these periods.")
else:
details.append("No dividend data available to assess payout consistency.")
return {"score": score, "details": "; ".join(details)}
def analyze_valuation_graham(financial_line_items: list, market_cap: float) -> dict:
if not financial_line_items or not market_cap or market_cap <= 0:
return {"score": 0, "details": "Insufficient data to perform valuation"}
latest = financial_line_items[0]
current_assets = latest.current_assets or 0
total_liabilities = latest.total_liabilities or 0
book_value_ps = latest.book_value_per_share or 0
eps = latest.earnings_per_share or 0
shares_outstanding = latest.outstanding_shares or 0
details = []
score = 0
# 1. Net-Net Check
# NCAV = Current Assets - Total Liabilities
# If NCAV > Market Cap => historically a strong buy signal
net_current_asset_value = current_assets - total_liabilities
if net_current_asset_value > 0 and shares_outstanding > 0:
net_current_asset_value_per_share = net_current_asset_value / shares_outstanding
price_per_share = market_cap / shares_outstanding if shares_outstanding else 0
details.append(f"Net Current Asset Value = {net_current_asset_value:,.2f}")
details.append(f"NCAV Per Share = {net_current_asset_value_per_share:,.2f}")
details.append(f"Price Per Share = {price_per_share:,.2f}")
if net_current_asset_value > market_cap:
score += 4 # Very strong Graham signal
details.append("Net-Net: NCAV > Market Cap (classic Graham deep value).")
else:
# For partial net-net discount
if net_current_asset_value_per_share >= (price_per_share * 0.67):
score += 2
details.append("NCAV Per Share >= 2/3 of Price Per Share (moderate net-net discount).")
else:
details.append("NCAV not exceeding market cap or insufficient data for net-net approach.")
# 2. Graham Number
# GrahamNumber = sqrt(22.5 * EPS * BVPS).
# Compare the result to the current price_per_share
# If GrahamNumber >> price, indicates undervaluation
graham_number = None
if eps > 0 and book_value_ps > 0:
graham_number = math.sqrt(22.5 * eps * book_value_ps)
details.append(f"Graham Number = {graham_number:.2f}")
else:
details.append("Unable to compute Graham Number (EPS or Book Value missing/<=0).")
# 3. Margin of Safety relative to Graham Number
if graham_number and shares_outstanding > 0:
current_price = market_cap / shares_outstanding
if current_price > 0:
margin_of_safety = (graham_number - current_price) / current_price
details.append(f"Margin of Safety (Graham Number) = {margin_of_safety:.2%}")
if margin_of_safety > 0.5:
score += 3
details.append("Price is well below Graham Number (>=50% margin).")
elif margin_of_safety > 0.2:
score += 1
details.append("Some margin of safety relative to Graham Number.")
else:
details.append("Price close to or above Graham Number, low margin of safety.")
else:
details.append("Current price is zero or invalid; can't compute margin of safety.")
# else: already appended details for missing graham_number
return {"score": score, "details": "; ".join(details)}
def generate_graham_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> BenGrahamSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Benjamin Graham AI agent, making investment decisions using his principles:
1. Insist on a margin of safety by buying below intrinsic value (e.g., using Graham Number, net-net).
2. Emphasize the company's financial strength (low leverage, ample current assets).
3. Prefer stable earnings over multiple years.
4. Consider dividend record for extra safety.
5. Avoid speculative or high-growth assumptions; focus on proven metrics.
When providing your reasoning, be thorough and specific by:
1. Explaining the key valuation metrics that influenced your decision the most (Graham Number, NCAV, P/E, etc.)
2. Highlighting the specific financial strength indicators (current ratio, debt levels, etc.)
3. Referencing the stability or instability of earnings over time
4. Providing quantitative evidence with precise numbers
5. Comparing current metrics to Graham's specific thresholds (e.g., "Current ratio of 2.5 exceeds Graham's minimum of 2.0")
6. Using Benjamin Graham's conservative, analytical voice and style in your explanation
For example, if bullish: "The stock trades at a 35% discount to net current asset value, providing an ample margin of safety. The current ratio of 2.5 and debt-to-equity of 0.3 indicate strong financial position..."
For example, if bearish: "Despite consistent earnings, the current price of $50 exceeds our calculated Graham Number of $35, offering no margin of safety. Additionally, the current ratio of only 1.2 falls below Graham's preferred 2.0 threshold..."
Return a rational recommendation: bullish, bearish, or neutral, with a confidence level (0-100) and thorough reasoning.
""",
),
(
"human",
"""Based on the following analysis, create a Graham-style investment signal:
Analysis Data for {ticker}:
{analysis_data}
Return JSON exactly in this format:
{{
"signal": "bullish" or "bearish" or "neutral",
"confidence": float (0-100),
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def create_default_ben_graham_signal():
return BenGrahamSignal(signal="neutral", confidence=0.0, reasoning="Error in generating analysis; defaulting to neutral.")
return call_llm(
prompt=prompt,
pydantic_model=BenGrahamSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_ben_graham_signal,
) | --- +++ @@ -18,6 +18,13 @@
def ben_graham_agent(state: AgentState, agent_id: str = "ben_graham_agent"):
+ """
+ Analyzes stocks using Benjamin Graham's classic value-investing principles:
+ 1. Earnings stability over multiple years.
+ 2. Solid financial strength (low debt, adequate liquidity).
+ 3. Discount to intrinsic value (e.g. Graham Number or net-net).
+ 4. Adequate margin of safety.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -88,6 +95,12 @@
def analyze_earnings_stability(metrics: list, financial_line_items: list) -> dict:
+ """
+ Graham wants at least several years of consistently positive earnings (ideally 5+).
+ We'll check:
+ 1. Number of years with positive EPS.
+ 2. Growth in EPS from first to last period.
+ """
score = 0
details = []
@@ -126,6 +139,10 @@
def analyze_financial_strength(financial_line_items: list) -> dict:
+ """
+ Graham checks liquidity (current ratio >= 2), manageable debt,
+ and dividend record (preferably some history of dividends).
+ """
score = 0
details = []
@@ -188,6 +205,12 @@
def analyze_valuation_graham(financial_line_items: list, market_cap: float) -> dict:
+ """
+ Core Graham approach to valuation:
+ 1. Net-Net Check: (Current Assets - Total Liabilities) vs. Market Cap
+ 2. Graham Number: sqrt(22.5 * EPS * Book Value per Share)
+ 3. Compare per-share price to Graham Number => margin of safety
+ """
if not financial_line_items or not market_cap or market_cap <= 0:
return {"score": 0, "details": "Insufficient data to perform valuation"}
@@ -262,6 +285,11 @@ state: AgentState,
agent_id: str,
) -> BenGrahamSignal:
+ """
+ Generates an investment decision in the style of Benjamin Graham:
+ - Value emphasis, margin of safety, net-nets, conservative balance sheet, stable earnings.
+ - Return the result in a JSON structure: { signal, confidence, reasoning }.
+ """
template = ChatPromptTemplate.from_messages(
[
@@ -317,4 +345,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_ben_graham_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/ben_graham.py |
Document classes and their methods | from typing import List, Optional
from sqlalchemy.orm import Session
from app.backend.database.models import HedgeFundFlow
class FlowRepository:
def __init__(self, db: Session):
self.db = db
def create_flow(self, name: str, nodes: dict, edges: dict, description: str = None,
viewport: dict = None, data: dict = None, is_template: bool = False, tags: List[str] = None) -> HedgeFundFlow:
flow = HedgeFundFlow(
name=name,
description=description,
nodes=nodes,
edges=edges,
viewport=viewport,
data=data,
is_template=is_template,
tags=tags or []
)
self.db.add(flow)
self.db.commit()
self.db.refresh(flow)
return flow
def get_flow_by_id(self, flow_id: int) -> Optional[HedgeFundFlow]:
return self.db.query(HedgeFundFlow).filter(HedgeFundFlow.id == flow_id).first()
def get_all_flows(self, include_templates: bool = True) -> List[HedgeFundFlow]:
query = self.db.query(HedgeFundFlow)
if not include_templates:
query = query.filter(HedgeFundFlow.is_template == False)
return query.order_by(HedgeFundFlow.updated_at.desc()).all()
def get_flows_by_name(self, name: str) -> List[HedgeFundFlow]:
return self.db.query(HedgeFundFlow).filter(
HedgeFundFlow.name.ilike(f"%{name}%")
).order_by(HedgeFundFlow.updated_at.desc()).all()
def update_flow(self, flow_id: int, name: str = None, description: str = None,
nodes: dict = None, edges: dict = None, viewport: dict = None, data: dict = None,
is_template: bool = None, tags: List[str] = None) -> Optional[HedgeFundFlow]:
flow = self.get_flow_by_id(flow_id)
if not flow:
return None
if name is not None:
flow.name = name
if description is not None:
flow.description = description
if nodes is not None:
flow.nodes = nodes
if edges is not None:
flow.edges = edges
if viewport is not None:
flow.viewport = viewport
if data is not None:
flow.data = data
if is_template is not None:
flow.is_template = is_template
if tags is not None:
flow.tags = tags
self.db.commit()
self.db.refresh(flow)
return flow
def delete_flow(self, flow_id: int) -> bool:
flow = self.get_flow_by_id(flow_id)
if not flow:
return False
self.db.delete(flow)
self.db.commit()
return True
def duplicate_flow(self, flow_id: int, new_name: str = None) -> Optional[HedgeFundFlow]:
original = self.get_flow_by_id(flow_id)
if not original:
return None
copy_name = new_name or f"{original.name} (Copy)"
return self.create_flow(
name=copy_name,
description=original.description,
nodes=original.nodes,
edges=original.edges,
viewport=original.viewport,
data=original.data,
is_template=False, # Copies are not templates by default
tags=original.tags
) | --- +++ @@ -4,12 +4,14 @@
class FlowRepository:
+ """Repository for HedgeFundFlow CRUD operations"""
def __init__(self, db: Session):
self.db = db
def create_flow(self, name: str, nodes: dict, edges: dict, description: str = None,
viewport: dict = None, data: dict = None, is_template: bool = False, tags: List[str] = None) -> HedgeFundFlow:
+ """Create a new hedge fund flow"""
flow = HedgeFundFlow(
name=name,
description=description,
@@ -26,15 +28,18 @@ return flow
def get_flow_by_id(self, flow_id: int) -> Optional[HedgeFundFlow]:
+ """Get a flow by its ID"""
return self.db.query(HedgeFundFlow).filter(HedgeFundFlow.id == flow_id).first()
def get_all_flows(self, include_templates: bool = True) -> List[HedgeFundFlow]:
+ """Get all flows, optionally excluding templates"""
query = self.db.query(HedgeFundFlow)
if not include_templates:
query = query.filter(HedgeFundFlow.is_template == False)
return query.order_by(HedgeFundFlow.updated_at.desc()).all()
def get_flows_by_name(self, name: str) -> List[HedgeFundFlow]:
+ """Search flows by name (case-insensitive partial match)"""
return self.db.query(HedgeFundFlow).filter(
HedgeFundFlow.name.ilike(f"%{name}%")
).order_by(HedgeFundFlow.updated_at.desc()).all()
@@ -42,6 +47,7 @@ def update_flow(self, flow_id: int, name: str = None, description: str = None,
nodes: dict = None, edges: dict = None, viewport: dict = None, data: dict = None,
is_template: bool = None, tags: List[str] = None) -> Optional[HedgeFundFlow]:
+ """Update an existing flow"""
flow = self.get_flow_by_id(flow_id)
if not flow:
return None
@@ -68,6 +74,7 @@ return flow
def delete_flow(self, flow_id: int) -> bool:
+ """Delete a flow by ID"""
flow = self.get_flow_by_id(flow_id)
if not flow:
return False
@@ -77,6 +84,7 @@ return True
def duplicate_flow(self, flow_id: int, new_name: str = None) -> Optional[HedgeFundFlow]:
+ """Create a copy of an existing flow"""
original = self.get_flow_by_id(flow_id)
if not original:
return None
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/repositories/flow_repository.py |
Generate consistent documentation across files | import asyncio
import os
import sys
import platform
import subprocess
import time
import re
import json
import queue
import threading
from pathlib import Path
from typing import Dict, List, Optional, AsyncGenerator
import logging
import signal
import ollama
logger = logging.getLogger(__name__)
class OllamaService:
def __init__(self):
self._download_progress = {}
self._download_processes = {}
# Initialize async client
self._async_client = ollama.AsyncClient()
self._sync_client = ollama.Client()
# =============================================================================
# PUBLIC API METHODS
# =============================================================================
async def check_ollama_status(self) -> Dict[str, any]:
try:
is_installed = await self._check_installation()
is_running = await self._check_server_running()
models, server_url = await self._get_server_info(is_running)
status = {
"installed": is_installed,
"running": is_running,
"server_running": is_running, # Backward compatibility
"available_models": models,
"server_url": server_url,
"error": None
}
logger.debug(f"Ollama status: installed={is_installed}, running={is_running}, models={len(models)}")
return status
except Exception as e:
logger.error(f"Error checking Ollama status: {e}")
return self._create_error_status(str(e))
async def start_server(self) -> Dict[str, any]:
try:
success = await self._execute_server_start()
message = "Ollama server started successfully" if success else "Failed to start Ollama server"
return {"success": success, "message": message}
except Exception as e:
logger.error(f"Error starting Ollama server: {e}")
return {"success": False, "message": f"Error starting server: {str(e)}"}
async def stop_server(self) -> Dict[str, any]:
try:
success = await self._execute_server_stop()
message = "Ollama server stopped successfully" if success else "Failed to stop Ollama server"
return {"success": success, "message": message}
except Exception as e:
logger.error(f"Error stopping Ollama server: {e}")
return {"success": False, "message": f"Error stopping server: {str(e)}"}
async def download_model(self, model_name: str) -> Dict[str, any]:
try:
success = await self._execute_model_download(model_name)
message = f"Model {model_name} downloaded successfully" if success else f"Failed to download model {model_name}"
return {"success": success, "message": message}
except Exception as e:
logger.error(f"Error downloading model {model_name}: {e}")
return {"success": False, "message": f"Error downloading model: {str(e)}"}
async def download_model_with_progress(self, model_name: str) -> AsyncGenerator[str, None]:
async for progress_data in self._stream_model_download(model_name):
yield progress_data
async def delete_model(self, model_name: str) -> Dict[str, any]:
try:
success = await self._execute_model_deletion(model_name)
message = f"Model {model_name} deleted successfully" if success else f"Failed to delete model {model_name}"
return {"success": success, "message": message}
except Exception as e:
logger.error(f"Error deleting model {model_name}: {e}")
return {"success": False, "message": f"Error deleting model: {str(e)}"}
async def get_recommended_models(self) -> List[Dict[str, str]]:
try:
models_path = self._get_ollama_models_path()
if models_path.exists():
return self._load_models_from_file(models_path)
else:
return self._get_fallback_models()
except Exception as e:
logger.error(f"Error loading recommended models: {e}")
return []
async def get_available_models(self) -> List[Dict[str, str]]:
try:
status = await self.check_ollama_status()
if not status.get("server_running", False):
logger.debug("Ollama server not running, returning no models for API")
return []
downloaded_models = status.get("available_models", [])
if not downloaded_models:
logger.debug("No Ollama models downloaded, returning empty list for API")
return []
api_models = self._format_models_for_api(downloaded_models)
logger.debug(f"Returning {len(api_models)} Ollama models for language models API")
return api_models
except Exception as e:
logger.error(f"Error getting available models for API: {e}")
return [] # Return empty list on error to not break the API
def get_download_progress(self, model_name: str) -> Optional[Dict[str, any]]:
return self._download_progress.get(model_name)
def get_all_download_progress(self) -> Dict[str, Dict[str, any]]:
return self._download_progress.copy()
def cancel_download(self, model_name: str) -> bool:
logger.warning(f"Download cancellation not directly supported by ollama client for model: {model_name}")
if model_name in self._download_progress:
self._download_progress[model_name] = {
"status": "cancelled",
"message": f"Download of {model_name} was cancelled",
"error": "Download cancelled by user"
}
return True
return False
# =============================================================================
# PRIVATE HELPER METHODS
# =============================================================================
def _create_error_status(self, error: str) -> Dict[str, any]:
return {
"installed": False,
"running": False,
"server_running": False,
"available_models": [],
"server_url": "",
"error": error
}
async def _check_installation(self) -> bool:
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, self._is_ollama_installed)
def _is_ollama_installed(self) -> bool:
system = platform.system().lower()
command = ["which", "ollama"] if system in ["darwin", "linux"] else ["where", "ollama"]
shell = system == "windows"
try:
result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=shell)
return result.returncode == 0
except Exception:
return False
async def _check_server_running(self) -> bool:
try:
await self._async_client.list()
logger.debug("Ollama server confirmed running via client")
return True
except Exception as e:
logger.debug(f"Ollama server not reachable: {e}")
return False
async def _get_server_info(self, is_running: bool) -> tuple[List[str], str]:
if not is_running:
return [], ""
try:
response = await self._async_client.list()
models = [model.model for model in response.models]
server_url = getattr(self._async_client, 'host', 'http://localhost:11434')
logger.debug(f"Found {len(models)} locally available models")
return models, server_url
except Exception as e:
logger.debug(f"Failed to get server info: {e}")
return [], ""
async def _execute_server_start(self) -> bool:
# Check if already running
try:
self._sync_client.list()
logger.info("Ollama server is already running")
return True
except Exception:
pass # Server not running, continue to start it
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, self._start_ollama_process)
def _start_ollama_process(self) -> bool:
system = platform.system().lower()
try:
command = ["ollama", "serve"]
shell = system == "windows"
subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=shell)
return self._wait_for_server_start()
except Exception as e:
logger.error(f"Error starting Ollama server: {e}")
return False
def _wait_for_server_start(self) -> bool:
logger.info("Starting Ollama server, waiting for it to become ready...")
for i in range(20): # Try for 20 seconds
time.sleep(1)
try:
self._sync_client.list()
logger.info(f"Ollama server started successfully after {i+1} seconds")
return True
except Exception:
logger.debug(f"Waiting for Ollama server... ({i+1}/20)")
continue
logger.error("Ollama server failed to start within 20 seconds")
return False
async def _execute_server_stop(self) -> bool:
# Check if already stopped
try:
self._sync_client.list()
except Exception:
logger.info("Ollama server is already stopped")
return True
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, self._stop_ollama_process)
def _stop_ollama_process(self) -> bool:
system = platform.system().lower()
try:
if system in ["darwin", "linux"]:
return self._stop_unix_process()
elif system == "windows":
return self._stop_windows_process()
else:
return False
except Exception as e:
logger.error(f"Error stopping Ollama server: {e}")
return False
def _stop_unix_process(self) -> bool:
try:
result = subprocess.run(
["pgrep", "-f", "ollama serve"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
if result.returncode == 0:
pids = [pid for pid in result.stdout.strip().split('\n') if pid]
self._terminate_processes(pids)
return self._verify_server_stopped()
except Exception as e:
logger.error(f"Error stopping Unix process: {e}")
return False
def _stop_windows_process(self) -> bool:
try:
subprocess.run(
["taskkill", "/F", "/IM", "ollama.exe"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
return self._verify_server_stopped()
except Exception as e:
logger.error(f"Error stopping Windows process: {e}")
return False
def _terminate_processes(self, pids: List[str]) -> None:
# Try SIGTERM first
for pid in pids:
if pid:
try:
os.kill(int(pid), signal.SIGTERM)
except (ValueError, ProcessLookupError, PermissionError):
continue
# Wait for graceful termination
for _ in range(5):
try:
self._sync_client.list()
time.sleep(1)
except Exception:
return # Server stopped
# Force kill if still running
for pid in pids:
if pid:
try:
os.kill(int(pid), signal.SIGKILL)
except (ValueError, ProcessLookupError, PermissionError):
continue
def _verify_server_stopped(self) -> bool:
for _ in range(3):
try:
self._sync_client.list()
time.sleep(1)
except Exception:
return True
return False
async def _execute_model_download(self, model_name: str) -> bool:
if not await self._check_server_running():
logger.error(f"Cannot download model {model_name}: Ollama server is not running")
return False
try:
logger.info(f"Starting download of model: {model_name}")
await self._async_client.pull(model_name)
logger.info(f"Successfully downloaded model: {model_name}")
return True
except Exception as e:
logger.error(f"Error downloading model {model_name}: {e}")
return False
async def _execute_model_deletion(self, model_name: str) -> bool:
if not await self._check_server_running():
logger.error(f"Cannot delete model {model_name}: Ollama server is not running")
return False
try:
logger.info(f"Deleting model: {model_name}")
await self._async_client.delete(model_name)
logger.info(f"Successfully deleted model: {model_name}")
return True
except Exception as e:
logger.error(f"Error deleting model {model_name}: {e}")
return False
async def _stream_model_download(self, model_name: str) -> AsyncGenerator[str, None]:
try:
if not await self._check_server_running():
yield f"data: {json.dumps({'status': 'error', 'error': 'Ollama server is not running'})}\n\n"
return
logger.info(f"Starting download of model: {model_name}")
self._download_progress[model_name] = {"status": "starting", "percentage": 0}
yield f"data: {json.dumps({'status': 'starting', 'percentage': 0, 'message': f'Starting download of {model_name}...'})}\n\n"
# Await the pull method to get the async iterator
pull_stream = await self._async_client.pull(model_name, stream=True)
async for progress in pull_stream:
progress_data = self._process_download_progress(progress, model_name)
if progress_data:
yield f"data: {json.dumps(progress_data)}\n\n"
if progress_data.get("status") == "completed":
logger.info(f"Successfully downloaded model: {model_name}")
break
except Exception as e:
error_data = {
"status": "error",
"message": f"Error downloading model {model_name}",
"error": str(e)
}
self._download_progress[model_name] = error_data
yield f"data: {json.dumps(error_data)}\n\n"
logger.error(f"Error downloading model {model_name}: {e}")
finally:
await asyncio.sleep(1)
if model_name in self._download_progress:
del self._download_progress[model_name]
def _process_download_progress(self, progress, model_name: str) -> Optional[Dict[str, any]]:
if not hasattr(progress, 'status'):
return None
progress_data = {
"status": "downloading",
"message": progress.status,
"raw_output": progress.status
}
# Add completed/total info if available
if (hasattr(progress, 'completed') and hasattr(progress, 'total') and
progress.total is not None and progress.completed is not None and progress.total > 0):
percentage = (progress.completed / progress.total) * 100
progress_data.update({
"percentage": percentage,
"bytes_downloaded": progress.completed,
"total_bytes": progress.total
})
# Add digest info if available
if hasattr(progress, 'digest'):
progress_data["digest"] = progress.digest
# Store in cache
self._download_progress[model_name] = progress_data
# Check if download is complete
if (progress.status == "success" or
(hasattr(progress, 'completed') and hasattr(progress, 'total') and
progress.completed is not None and progress.total is not None and
progress.completed == progress.total)):
final_data = {
"status": "completed",
"percentage": 100,
"message": f"Model {model_name} downloaded successfully!"
}
self._download_progress[model_name] = final_data
return final_data
return progress_data
def _get_ollama_models_path(self) -> Path:
return Path(__file__).parent.parent.parent.parent / "src" / "llm" / "ollama_models.json"
def _load_models_from_file(self, models_path: Path) -> List[Dict[str, str]]:
with open(models_path, 'r') as f:
return json.load(f)
def _get_fallback_models(self) -> List[Dict[str, str]]:
return [
{"display_name": "[meta] llama3.1 (8B)", "model_name": "llama3.1:latest", "provider": "Ollama"},
{"display_name": "[google] gemma3 (4B)", "model_name": "gemma3:4b", "provider": "Ollama"},
{"display_name": "[alibaba] qwen3 (4B)", "model_name": "qwen3:4b", "provider": "Ollama"},
]
def _format_models_for_api(self, downloaded_models: List[str]) -> List[Dict[str, str]]:
# Import OLLAMA_MODELS here to avoid circular imports
from src.llm.models import OLLAMA_MODELS
api_models = []
for ollama_model in OLLAMA_MODELS:
if ollama_model.model_name in downloaded_models:
api_models.append({
"display_name": ollama_model.display_name,
"model_name": ollama_model.model_name,
"provider": "Ollama"
})
return api_models
# Global service instance
ollama_service = OllamaService() | --- +++ @@ -17,6 +17,7 @@ logger = logging.getLogger(__name__)
class OllamaService:
+ """Service for managing Ollama integration in the backend."""
def __init__(self):
self._download_progress = {}
@@ -31,6 +32,7 @@ # =============================================================================
async def check_ollama_status(self) -> Dict[str, any]:
+ """Check Ollama installation and server status."""
try:
is_installed = await self._check_installation()
is_running = await self._check_server_running()
@@ -53,6 +55,7 @@ return self._create_error_status(str(e))
async def start_server(self) -> Dict[str, any]:
+ """Start the Ollama server."""
try:
success = await self._execute_server_start()
@@ -64,6 +67,7 @@ return {"success": False, "message": f"Error starting server: {str(e)}"}
async def stop_server(self) -> Dict[str, any]:
+ """Stop the Ollama server."""
try:
success = await self._execute_server_stop()
@@ -75,6 +79,7 @@ return {"success": False, "message": f"Error stopping server: {str(e)}"}
async def download_model(self, model_name: str) -> Dict[str, any]:
+ """Download an Ollama model."""
try:
success = await self._execute_model_download(model_name)
@@ -86,10 +91,12 @@ return {"success": False, "message": f"Error downloading model: {str(e)}"}
async def download_model_with_progress(self, model_name: str) -> AsyncGenerator[str, None]:
+ """Download an Ollama model with progress streaming."""
async for progress_data in self._stream_model_download(model_name):
yield progress_data
async def delete_model(self, model_name: str) -> Dict[str, any]:
+ """Delete an Ollama model."""
try:
success = await self._execute_model_deletion(model_name)
@@ -101,6 +108,7 @@ return {"success": False, "message": f"Error deleting model: {str(e)}"}
async def get_recommended_models(self) -> List[Dict[str, str]]:
+ """Get list of recommended Ollama models."""
try:
models_path = self._get_ollama_models_path()
@@ -114,6 +122,13 @@ return []
async def get_available_models(self) -> List[Dict[str, str]]:
+ """Get available Ollama models formatted for the language models API.
+
+ Returns only models that are:
+ 1. Server is running
+ 2. Model is downloaded locally
+ 3. Model is in our recommended list (OLLAMA_MODELS)
+ """
try:
status = await self.check_ollama_status()
@@ -135,12 +150,15 @@ return [] # Return empty list on error to not break the API
def get_download_progress(self, model_name: str) -> Optional[Dict[str, any]]:
+ """Get current download progress for a model."""
return self._download_progress.get(model_name)
def get_all_download_progress(self) -> Dict[str, Dict[str, any]]:
+ """Get current download progress for all models."""
return self._download_progress.copy()
def cancel_download(self, model_name: str) -> bool:
+ """Cancel an active download."""
logger.warning(f"Download cancellation not directly supported by ollama client for model: {model_name}")
if model_name in self._download_progress:
@@ -159,6 +177,7 @@
def _create_error_status(self, error: str) -> Dict[str, any]:
+ """Create error status response."""
return {
"installed": False,
"running": False,
@@ -169,10 +188,12 @@ }
async def _check_installation(self) -> bool:
+ """Check if Ollama CLI is installed."""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, self._is_ollama_installed)
def _is_ollama_installed(self) -> bool:
+ """Check if Ollama is installed on the system."""
system = platform.system().lower()
command = ["which", "ollama"] if system in ["darwin", "linux"] else ["where", "ollama"]
shell = system == "windows"
@@ -184,6 +205,7 @@ return False
async def _check_server_running(self) -> bool:
+ """Check if the Ollama server is running using the ollama client."""
try:
await self._async_client.list()
logger.debug("Ollama server confirmed running via client")
@@ -193,6 +215,7 @@ return False
async def _get_server_info(self, is_running: bool) -> tuple[List[str], str]:
+ """Get server information (models and URL) if server is running."""
if not is_running:
return [], ""
@@ -207,6 +230,7 @@ return [], ""
async def _execute_server_start(self) -> bool:
+ """Execute server start operation."""
# Check if already running
try:
self._sync_client.list()
@@ -219,6 +243,7 @@ return await loop.run_in_executor(None, self._start_ollama_process)
def _start_ollama_process(self) -> bool:
+ """Start the Ollama server process."""
system = platform.system().lower()
try:
@@ -233,6 +258,7 @@ return False
def _wait_for_server_start(self) -> bool:
+ """Wait for server to start and become ready."""
logger.info("Starting Ollama server, waiting for it to become ready...")
for i in range(20): # Try for 20 seconds
@@ -249,6 +275,7 @@ return False
async def _execute_server_stop(self) -> bool:
+ """Execute server stop operation."""
# Check if already stopped
try:
self._sync_client.list()
@@ -260,6 +287,7 @@ return await loop.run_in_executor(None, self._stop_ollama_process)
def _stop_ollama_process(self) -> bool:
+ """Stop the Ollama server process."""
system = platform.system().lower()
try:
@@ -275,6 +303,7 @@ return False
def _stop_unix_process(self) -> bool:
+ """Stop Ollama on Unix-like systems."""
try:
result = subprocess.run(
["pgrep", "-f", "ollama serve"],
@@ -294,6 +323,7 @@ return False
def _stop_windows_process(self) -> bool:
+ """Stop Ollama on Windows."""
try:
subprocess.run(
["taskkill", "/F", "/IM", "ollama.exe"],
@@ -307,6 +337,7 @@ return False
def _terminate_processes(self, pids: List[str]) -> None:
+ """Terminate processes gracefully, then forcefully if needed."""
# Try SIGTERM first
for pid in pids:
if pid:
@@ -332,6 +363,7 @@ continue
def _verify_server_stopped(self) -> bool:
+ """Verify that the server has stopped."""
for _ in range(3):
try:
self._sync_client.list()
@@ -341,6 +373,7 @@ return False
async def _execute_model_download(self, model_name: str) -> bool:
+ """Execute model download operation."""
if not await self._check_server_running():
logger.error(f"Cannot download model {model_name}: Ollama server is not running")
return False
@@ -355,6 +388,7 @@ return False
async def _execute_model_deletion(self, model_name: str) -> bool:
+ """Execute model deletion operation."""
if not await self._check_server_running():
logger.error(f"Cannot delete model {model_name}: Ollama server is not running")
return False
@@ -369,6 +403,7 @@ return False
async def _stream_model_download(self, model_name: str) -> AsyncGenerator[str, None]:
+ """Stream model download with progress updates."""
try:
if not await self._check_server_running():
yield f"data: {json.dumps({'status': 'error', 'error': 'Ollama server is not running'})}\n\n"
@@ -405,6 +440,7 @@ del self._download_progress[model_name]
def _process_download_progress(self, progress, model_name: str) -> Optional[Dict[str, any]]:
+ """Process download progress from ollama client."""
if not hasattr(progress, 'status'):
return None
@@ -447,13 +483,16 @@ return progress_data
def _get_ollama_models_path(self) -> Path:
+ """Get path to ollama_models.json file."""
return Path(__file__).parent.parent.parent.parent / "src" / "llm" / "ollama_models.json"
def _load_models_from_file(self, models_path: Path) -> List[Dict[str, str]]:
+ """Load models from JSON file."""
with open(models_path, 'r') as f:
return json.load(f)
def _get_fallback_models(self) -> List[Dict[str, str]]:
+ """Get fallback models when file is not available."""
return [
{"display_name": "[meta] llama3.1 (8B)", "model_name": "llama3.1:latest", "provider": "Ollama"},
{"display_name": "[google] gemma3 (4B)", "model_name": "gemma3:4b", "provider": "Ollama"},
@@ -461,6 +500,7 @@ ]
def _format_models_for_api(self, downloaded_models: List[str]) -> List[Dict[str, str]]:
+ """Format downloaded models for API response."""
# Import OLLAMA_MODELS here to avoid circular imports
from src.llm.models import OLLAMA_MODELS
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/services/ollama_service.py |
Annotate my code with docstrings | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
from src.utils.api_key import get_api_key_from_state
class BillAckmanSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def bill_ackman_agent(state: AgentState, agent_id: str = "bill_ackman_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
ackman_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
# Request multiple periods of data (annual or TTM) for a more robust long-term view.
financial_line_items = search_line_items(
ticker,
[
"revenue",
"operating_margin",
"debt_to_equity",
"free_cash_flow",
"total_assets",
"total_liabilities",
"dividends_and_other_cash_distributions",
"outstanding_shares",
# Optional: intangible_assets if available
# "intangible_assets"
],
end_date,
period="annual",
limit=5,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing business quality")
quality_analysis = analyze_business_quality(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing balance sheet and capital structure")
balance_sheet_analysis = analyze_financial_discipline(metrics, financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing activism potential")
activism_analysis = analyze_activism_potential(financial_line_items)
progress.update_status(agent_id, ticker, "Calculating intrinsic value & margin of safety")
valuation_analysis = analyze_valuation(financial_line_items, market_cap)
# Combine partial scores or signals
total_score = (
quality_analysis["score"]
+ balance_sheet_analysis["score"]
+ activism_analysis["score"]
+ valuation_analysis["score"]
)
max_possible_score = 20 # Adjust weighting as desired (5 from each sub-analysis, for instance)
# Generate a simple buy/hold/sell (bullish/neutral/bearish) signal
if total_score >= 0.7 * max_possible_score:
signal = "bullish"
elif total_score <= 0.3 * max_possible_score:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_possible_score,
"quality_analysis": quality_analysis,
"balance_sheet_analysis": balance_sheet_analysis,
"activism_analysis": activism_analysis,
"valuation_analysis": valuation_analysis
}
progress.update_status(agent_id, ticker, "Generating Bill Ackman analysis")
ackman_output = generate_ackman_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
ackman_analysis[ticker] = {
"signal": ackman_output.signal,
"confidence": ackman_output.confidence,
"reasoning": ackman_output.reasoning
}
progress.update_status(agent_id, ticker, "Done", analysis=ackman_output.reasoning)
# Wrap results in a single message for the chain
message = HumanMessage(
content=json.dumps(ackman_analysis),
name=agent_id
)
# Show reasoning if requested
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(ackman_analysis, "Bill Ackman Agent")
# Add signals to the overall state
state["data"]["analyst_signals"][agent_id] = ackman_analysis
progress.update_status(agent_id, None, "Done")
return {
"messages": [message],
"data": state["data"]
}
def analyze_business_quality(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {
"score": 0,
"details": "Insufficient data to analyze business quality"
}
# 1. Multi-period revenue growth analysis
revenues = [item.revenue for item in financial_line_items if item.revenue is not None]
if len(revenues) >= 2:
initial, final = revenues[-1], revenues[0]
if initial and final and final > initial:
growth_rate = (final - initial) / abs(initial)
if growth_rate > 0.5: # e.g., 50% cumulative growth
score += 2
details.append(f"Revenue grew by {(growth_rate*100):.1f}% over the full period (strong growth).")
else:
score += 1
details.append(f"Revenue growth is positive but under 50% cumulatively ({(growth_rate*100):.1f}%).")
else:
details.append("Revenue did not grow significantly or data insufficient.")
else:
details.append("Not enough revenue data for multi-period trend.")
# 2. Operating margin and free cash flow consistency
fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow is not None]
op_margin_vals = [item.operating_margin for item in financial_line_items if item.operating_margin is not None]
if op_margin_vals:
above_15 = sum(1 for m in op_margin_vals if m > 0.15)
if above_15 >= (len(op_margin_vals) // 2 + 1):
score += 2
details.append("Operating margins have often exceeded 15% (indicates good profitability).")
else:
details.append("Operating margin not consistently above 15%.")
else:
details.append("No operating margin data across periods.")
if fcf_vals:
positive_fcf_count = sum(1 for f in fcf_vals if f > 0)
if positive_fcf_count >= (len(fcf_vals) // 2 + 1):
score += 1
details.append("Majority of periods show positive free cash flow.")
else:
details.append("Free cash flow not consistently positive.")
else:
details.append("No free cash flow data across periods.")
# 3. Return on Equity (ROE) check from the latest metrics
latest_metrics = metrics[0]
if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15:
score += 2
details.append(f"High ROE of {latest_metrics.return_on_equity:.1%}, indicating a competitive advantage.")
elif latest_metrics.return_on_equity:
details.append(f"ROE of {latest_metrics.return_on_equity:.1%} is moderate.")
else:
details.append("ROE data not available.")
# 4. (Optional) Brand Intangible (if intangible_assets are fetched)
# intangible_vals = [item.intangible_assets for item in financial_line_items if item.intangible_assets]
# if intangible_vals and sum(intangible_vals) > 0:
# details.append("Significant intangible assets may indicate brand value or proprietary tech.")
# score += 1
return {
"score": score,
"details": "; ".join(details)
}
def analyze_financial_discipline(metrics: list, financial_line_items: list) -> dict:
score = 0
details = []
if not metrics or not financial_line_items:
return {
"score": 0,
"details": "Insufficient data to analyze financial discipline"
}
# 1. Multi-period debt ratio or debt_to_equity
debt_to_equity_vals = [item.debt_to_equity for item in financial_line_items if item.debt_to_equity is not None]
if debt_to_equity_vals:
below_one_count = sum(1 for d in debt_to_equity_vals if d < 1.0)
if below_one_count >= (len(debt_to_equity_vals) // 2 + 1):
score += 2
details.append("Debt-to-equity < 1.0 for the majority of periods (reasonable leverage).")
else:
details.append("Debt-to-equity >= 1.0 in many periods (could be high leverage).")
else:
# Fallback to total_liabilities / total_assets
liab_to_assets = []
for item in financial_line_items:
if item.total_liabilities and item.total_assets and item.total_assets > 0:
liab_to_assets.append(item.total_liabilities / item.total_assets)
if liab_to_assets:
below_50pct_count = sum(1 for ratio in liab_to_assets if ratio < 0.5)
if below_50pct_count >= (len(liab_to_assets) // 2 + 1):
score += 2
details.append("Liabilities-to-assets < 50% for majority of periods.")
else:
details.append("Liabilities-to-assets >= 50% in many periods.")
else:
details.append("No consistent leverage ratio data available.")
# 2. Capital allocation approach (dividends + share counts)
dividends_list = [
item.dividends_and_other_cash_distributions
for item in financial_line_items
if item.dividends_and_other_cash_distributions is not None
]
if dividends_list:
paying_dividends_count = sum(1 for d in dividends_list if d < 0)
if paying_dividends_count >= (len(dividends_list) // 2 + 1):
score += 1
details.append("Company has a history of returning capital to shareholders (dividends).")
else:
details.append("Dividends not consistently paid or no data on distributions.")
else:
details.append("No dividend data found across periods.")
# Check for decreasing share count (simple approach)
shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares is not None]
if len(shares) >= 2:
# For buybacks, the newest count should be less than the oldest count
if shares[0] < shares[-1]:
score += 1
details.append("Outstanding shares have decreased over time (possible buybacks).")
else:
details.append("Outstanding shares have not decreased over the available periods.")
else:
details.append("No multi-period share count data to assess buybacks.")
return {
"score": score,
"details": "; ".join(details)
}
def analyze_activism_potential(financial_line_items: list) -> dict:
if not financial_line_items:
return {
"score": 0,
"details": "Insufficient data for activism potential"
}
# Check revenue growth vs. operating margin
revenues = [item.revenue for item in financial_line_items if item.revenue is not None]
op_margins = [item.operating_margin for item in financial_line_items if item.operating_margin is not None]
if len(revenues) < 2 or not op_margins:
return {
"score": 0,
"details": "Not enough data to assess activism potential (need multi-year revenue + margins)."
}
initial, final = revenues[-1], revenues[0]
revenue_growth = (final - initial) / abs(initial) if initial else 0
avg_margin = sum(op_margins) / len(op_margins)
score = 0
details = []
# Suppose if there's decent revenue growth but margins are below 10%, Ackman might see activism potential.
if revenue_growth > 0.15 and avg_margin < 0.10:
score += 2
details.append(
f"Revenue growth is healthy (~{revenue_growth*100:.1f}%), but margins are low (avg {avg_margin*100:.1f}%). "
"Activism could unlock margin improvements."
)
else:
details.append("No clear sign of activism opportunity (either margins are already decent or growth is weak).")
return {"score": score, "details": "; ".join(details)}
def analyze_valuation(financial_line_items: list, market_cap: float) -> dict:
if not financial_line_items or market_cap is None:
return {
"score": 0,
"details": "Insufficient data to perform valuation"
}
# Since financial_line_items are in descending order (newest first),
# the most recent period is the first element
latest = financial_line_items[0]
fcf = latest.free_cash_flow if latest.free_cash_flow else 0
if fcf <= 0:
return {
"score": 0,
"details": f"No positive FCF for valuation; FCF = {fcf}",
"intrinsic_value": None
}
# Basic DCF assumptions
growth_rate = 0.06
discount_rate = 0.10
terminal_multiple = 15
projection_years = 5
present_value = 0
for year in range(1, projection_years + 1):
future_fcf = fcf * (1 + growth_rate) ** year
pv = future_fcf / ((1 + discount_rate) ** year)
present_value += pv
# Terminal Value
terminal_value = (
fcf * (1 + growth_rate) ** projection_years * terminal_multiple
) / ((1 + discount_rate) ** projection_years)
intrinsic_value = present_value + terminal_value
margin_of_safety = (intrinsic_value - market_cap) / market_cap
score = 0
# Simple scoring
if margin_of_safety > 0.3:
score += 3
elif margin_of_safety > 0.1:
score += 1
details = [
f"Calculated intrinsic value: ~{intrinsic_value:,.2f}",
f"Market cap: ~{market_cap:,.2f}",
f"Margin of safety: {margin_of_safety:.2%}"
]
return {
"score": score,
"details": "; ".join(details),
"intrinsic_value": intrinsic_value,
"margin_of_safety": margin_of_safety
}
def generate_ackman_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> BillAckmanSignal:
template = ChatPromptTemplate.from_messages([
(
"system",
"""You are a Bill Ackman AI agent, making investment decisions using his principles:
1. Seek high-quality businesses with durable competitive advantages (moats), often in well-known consumer or service brands.
2. Prioritize consistent free cash flow and growth potential over the long term.
3. Advocate for strong financial discipline (reasonable leverage, efficient capital allocation).
4. Valuation matters: target intrinsic value with a margin of safety.
5. Consider activism where management or operational improvements can unlock substantial upside.
6. Concentrate on a few high-conviction investments.
In your reasoning:
- Emphasize brand strength, moat, or unique market positioning.
- Review free cash flow generation and margin trends as key signals.
- Analyze leverage, share buybacks, and dividends as capital discipline metrics.
- Provide a valuation assessment with numerical backup (DCF, multiples, etc.).
- Identify any catalysts for activism or value creation (e.g., cost cuts, better capital allocation).
- Use a confident, analytic, and sometimes confrontational tone when discussing weaknesses or opportunities.
Return your final recommendation (signal: bullish, neutral, or bearish) with a 0-100 confidence and a thorough reasoning section.
"""
),
(
"human",
"""Based on the following analysis, create an Ackman-style investment signal.
Analysis Data for {ticker}:
{analysis_data}
Return your output in strictly valid JSON:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": float (0-100),
"reasoning": "string"
}}
"""
)
])
prompt = template.invoke({
"analysis_data": json.dumps(analysis_data, indent=2),
"ticker": ticker
})
def create_default_bill_ackman_signal():
return BillAckmanSignal(
signal="neutral",
confidence=0.0,
reasoning="Error in analysis, defaulting to neutral"
)
return call_llm(
prompt=prompt,
pydantic_model=BillAckmanSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_bill_ackman_signal,
) | --- +++ @@ -17,6 +17,11 @@
def bill_ackman_agent(state: AgentState, agent_id: str = "bill_ackman_agent"):
+ """
+ Analyzes stocks using Bill Ackman's investing principles and LLM reasoning.
+ Fetches multiple periods of data for a more robust long-term view.
+ Incorporates brand/competitive advantage, activism potential, and other key factors.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -130,6 +135,11 @@
def analyze_business_quality(metrics: list, financial_line_items: list) -> dict:
+ """
+ Analyze whether the company has a high-quality business with stable or growing cash flows,
+ durable competitive advantages (moats), and potential for long-term growth.
+ Also tries to infer brand strength if intangible_assets data is present (optional).
+ """
score = 0
details = []
@@ -203,6 +213,11 @@
def analyze_financial_discipline(metrics: list, financial_line_items: list) -> dict:
+ """
+ Evaluate the company's balance sheet over multiple periods:
+ - Debt ratio trends
+ - Capital returns to shareholders over time (dividends, buybacks)
+ """
score = 0
details = []
@@ -273,6 +288,14 @@
def analyze_activism_potential(financial_line_items: list) -> dict:
+ """
+ Bill Ackman often engages in activism if a company has a decent brand or moat
+ but is underperforming operationally.
+
+ We'll do a simplified approach:
+ - Look for positive revenue trends but subpar margins
+ - That may indicate 'activism upside' if operational improvements could unlock value.
+ """
if not financial_line_items:
return {
"score": 0,
@@ -310,6 +333,10 @@
def analyze_valuation(financial_line_items: list, market_cap: float) -> dict:
+ """
+ Ackman invests in companies trading at a discount to intrinsic value.
+ Uses a simplified DCF with FCF as a proxy, plus margin of safety analysis.
+ """
if not financial_line_items or market_cap is None:
return {
"score": 0,
@@ -375,6 +402,11 @@ state: AgentState,
agent_id: str,
) -> BillAckmanSignal:
+ """
+ Generates investment decisions in the style of Bill Ackman.
+ Includes more explicit references to brand strength, activism potential,
+ catalysts, and management changes in the system prompt.
+ """
template = ChatPromptTemplate.from_messages([
(
"system",
@@ -433,4 +465,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_bill_ackman_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/bill_ackman.py |
Write Python docstrings for this snippet | from __future__ import annotations
"""Valuation Agent
Implements four complementary valuation methodologies and aggregates them with
configurable weights.
"""
import json
import statistics
from langchain_core.messages import HumanMessage
from src.graph.state import AgentState, show_agent_reasoning
from src.utils.progress import progress
from src.utils.api_key import get_api_key_from_state
from src.tools.api import (
get_financial_metrics,
get_market_cap,
search_line_items,
)
def valuation_analyst_agent(state: AgentState, agent_id: str = "valuation_analyst_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
valuation_analysis: dict[str, dict] = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial data")
# --- Historical financial metrics ---
financial_metrics = get_financial_metrics(
ticker=ticker,
end_date=end_date,
period="ttm",
limit=8,
api_key=api_key,
)
if not financial_metrics:
progress.update_status(agent_id, ticker, "Failed: No financial metrics found")
continue
most_recent_metrics = financial_metrics[0]
# --- Enhanced line‑items ---
progress.update_status(agent_id, ticker, "Gathering comprehensive line items")
line_items = search_line_items(
ticker=ticker,
line_items=[
"free_cash_flow",
"net_income",
"depreciation_and_amortization",
"capital_expenditure",
"working_capital",
"total_debt",
"cash_and_equivalents",
"interest_expense",
"revenue",
"operating_income",
"ebit",
"ebitda"
],
end_date=end_date,
period="ttm",
limit=8,
api_key=api_key,
)
if len(line_items) < 2:
progress.update_status(agent_id, ticker, "Failed: Insufficient financial line items")
continue
li_curr, li_prev = line_items[0], line_items[1]
# ------------------------------------------------------------------
# Valuation models
# ------------------------------------------------------------------
# Handle potential None values for working capital
if li_curr.working_capital is not None and li_prev.working_capital is not None:
wc_change = li_curr.working_capital - li_prev.working_capital
else:
wc_change = 0 # Default to 0 if working capital data is unavailable
# Owner Earnings
owner_val = calculate_owner_earnings_value(
net_income=li_curr.net_income,
depreciation=li_curr.depreciation_and_amortization,
capex=li_curr.capital_expenditure,
working_capital_change=wc_change,
growth_rate=most_recent_metrics.earnings_growth or 0.05,
)
# Enhanced Discounted Cash Flow with WACC and scenarios
progress.update_status(agent_id, ticker, "Calculating WACC and enhanced DCF")
# Calculate WACC
wacc = calculate_wacc(
market_cap=most_recent_metrics.market_cap or 0,
total_debt=getattr(li_curr, 'total_debt', None),
cash=getattr(li_curr, 'cash_and_equivalents', None),
interest_coverage=most_recent_metrics.interest_coverage,
debt_to_equity=most_recent_metrics.debt_to_equity,
)
# Prepare FCF history for enhanced DCF
fcf_history = []
for li in line_items:
if hasattr(li, 'free_cash_flow') and li.free_cash_flow is not None:
fcf_history.append(li.free_cash_flow)
# Enhanced DCF with scenarios
dcf_results = calculate_dcf_scenarios(
fcf_history=fcf_history,
growth_metrics={
'revenue_growth': most_recent_metrics.revenue_growth,
'fcf_growth': most_recent_metrics.free_cash_flow_growth,
'earnings_growth': most_recent_metrics.earnings_growth
},
wacc=wacc,
market_cap=most_recent_metrics.market_cap or 0,
revenue_growth=most_recent_metrics.revenue_growth
)
dcf_val = dcf_results['expected_value']
# Implied Equity Value
ev_ebitda_val = calculate_ev_ebitda_value(financial_metrics)
# Residual Income Model
rim_val = calculate_residual_income_value(
market_cap=most_recent_metrics.market_cap,
net_income=li_curr.net_income,
price_to_book_ratio=most_recent_metrics.price_to_book_ratio,
book_value_growth=most_recent_metrics.book_value_growth or 0.03,
)
# ------------------------------------------------------------------
# Aggregate & signal
# ------------------------------------------------------------------
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
if not market_cap:
progress.update_status(agent_id, ticker, "Failed: Market cap unavailable")
continue
method_values = {
"dcf": {"value": dcf_val, "weight": 0.35},
"owner_earnings": {"value": owner_val, "weight": 0.35},
"ev_ebitda": {"value": ev_ebitda_val, "weight": 0.20},
"residual_income": {"value": rim_val, "weight": 0.10},
}
total_weight = sum(v["weight"] for v in method_values.values() if v["value"] > 0)
if total_weight == 0:
progress.update_status(agent_id, ticker, "Failed: All valuation methods zero")
continue
for v in method_values.values():
v["gap"] = (v["value"] - market_cap) / market_cap if v["value"] > 0 else None
weighted_gap = sum(
v["weight"] * v["gap"] for v in method_values.values() if v["gap"] is not None
) / total_weight
signal = "bullish" if weighted_gap > 0.15 else "bearish" if weighted_gap < -0.15 else "neutral"
confidence = round(min(abs(weighted_gap) / 0.30 * 100, 100))
# Enhanced reasoning with DCF scenario details
reasoning = {}
for m, vals in method_values.items():
if vals["value"] > 0:
base_details = (
f"Value: ${vals['value']:,.2f}, Market Cap: ${market_cap:,.2f}, "
f"Gap: {vals['gap']:.1%}, Weight: {vals['weight']*100:.0f}%"
)
# Add enhanced DCF details
if m == "dcf" and 'dcf_results' in locals():
enhanced_details = (
f"{base_details}\n"
f" WACC: {wacc:.1%}, Bear: ${dcf_results['downside']:,.2f}, "
f"Bull: ${dcf_results['upside']:,.2f}, Range: ${dcf_results['range']:,.2f}"
)
else:
enhanced_details = base_details
reasoning[f"{m}_analysis"] = {
"signal": (
"bullish" if vals["gap"] and vals["gap"] > 0.15 else
"bearish" if vals["gap"] and vals["gap"] < -0.15 else "neutral"
),
"details": enhanced_details,
}
# Add overall DCF scenario summary if available
if 'dcf_results' in locals():
reasoning["dcf_scenario_analysis"] = {
"bear_case": f"${dcf_results['downside']:,.2f}",
"base_case": f"${dcf_results['scenarios']['base']:,.2f}",
"bull_case": f"${dcf_results['upside']:,.2f}",
"wacc_used": f"{wacc:.1%}",
"fcf_periods_analyzed": len(fcf_history)
}
valuation_analysis[ticker] = {
"signal": signal,
"confidence": confidence,
"reasoning": reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=json.dumps(reasoning, indent=4))
# ---- Emit message (for LLM tool chain) ----
msg = HumanMessage(content=json.dumps(valuation_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(valuation_analysis, "Valuation Analysis Agent")
# Add the signal to the analyst_signals list
state["data"]["analyst_signals"][agent_id] = valuation_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [msg], "data": data}
#############################
# Helper Valuation Functions
#############################
def calculate_owner_earnings_value(
net_income: float | None,
depreciation: float | None,
capex: float | None,
working_capital_change: float | None,
growth_rate: float = 0.05,
required_return: float = 0.15,
margin_of_safety: float = 0.25,
num_years: int = 5,
) -> float:
if not all(isinstance(x, (int, float)) for x in [net_income, depreciation, capex, working_capital_change]):
return 0
owner_earnings = net_income + depreciation - capex - working_capital_change
if owner_earnings <= 0:
return 0
pv = 0.0
for yr in range(1, num_years + 1):
future = owner_earnings * (1 + growth_rate) ** yr
pv += future / (1 + required_return) ** yr
terminal_growth = min(growth_rate, 0.03)
term_val = (owner_earnings * (1 + growth_rate) ** num_years * (1 + terminal_growth)) / (
required_return - terminal_growth
)
pv_term = term_val / (1 + required_return) ** num_years
intrinsic = pv + pv_term
return intrinsic * (1 - margin_of_safety)
def calculate_intrinsic_value(
free_cash_flow: float | None,
growth_rate: float = 0.05,
discount_rate: float = 0.10,
terminal_growth_rate: float = 0.02,
num_years: int = 5,
) -> float:
if free_cash_flow is None or free_cash_flow <= 0:
return 0
pv = 0.0
for yr in range(1, num_years + 1):
fcft = free_cash_flow * (1 + growth_rate) ** yr
pv += fcft / (1 + discount_rate) ** yr
term_val = (
free_cash_flow * (1 + growth_rate) ** num_years * (1 + terminal_growth_rate)
) / (discount_rate - terminal_growth_rate)
pv_term = term_val / (1 + discount_rate) ** num_years
return pv + pv_term
def calculate_ev_ebitda_value(financial_metrics: list):
if not financial_metrics:
return 0
m0 = financial_metrics[0]
if not (m0.enterprise_value and m0.enterprise_value_to_ebitda_ratio):
return 0
if m0.enterprise_value_to_ebitda_ratio == 0:
return 0
ebitda_now = m0.enterprise_value / m0.enterprise_value_to_ebitda_ratio
med_mult = statistics.median([
m.enterprise_value_to_ebitda_ratio for m in financial_metrics if m.enterprise_value_to_ebitda_ratio
])
ev_implied = med_mult * ebitda_now
net_debt = (m0.enterprise_value or 0) - (m0.market_cap or 0)
return max(ev_implied - net_debt, 0)
def calculate_residual_income_value(
market_cap: float | None,
net_income: float | None,
price_to_book_ratio: float | None,
book_value_growth: float = 0.03,
cost_of_equity: float = 0.10,
terminal_growth_rate: float = 0.03,
num_years: int = 5,
):
if not (market_cap and net_income and price_to_book_ratio and price_to_book_ratio > 0):
return 0
book_val = market_cap / price_to_book_ratio
ri0 = net_income - cost_of_equity * book_val
if ri0 <= 0:
return 0
pv_ri = 0.0
for yr in range(1, num_years + 1):
ri_t = ri0 * (1 + book_value_growth) ** yr
pv_ri += ri_t / (1 + cost_of_equity) ** yr
term_ri = ri0 * (1 + book_value_growth) ** (num_years + 1) / (
cost_of_equity - terminal_growth_rate
)
pv_term = term_ri / (1 + cost_of_equity) ** num_years
intrinsic = book_val + pv_ri + pv_term
return intrinsic * 0.8 # 20% margin of safety
####################################
# Enhanced DCF Helper Functions
####################################
def calculate_wacc(
market_cap: float,
total_debt: float | None,
cash: float | None,
interest_coverage: float | None,
debt_to_equity: float | None,
beta_proxy: float = 1.0,
risk_free_rate: float = 0.045,
market_risk_premium: float = 0.06
) -> float:
# Cost of Equity (CAPM)
cost_of_equity = risk_free_rate + beta_proxy * market_risk_premium
# Cost of Debt - estimate from interest coverage
if interest_coverage and interest_coverage > 0:
# Higher coverage = lower cost of debt
cost_of_debt = max(risk_free_rate + 0.01, risk_free_rate + (10 / interest_coverage))
else:
cost_of_debt = risk_free_rate + 0.05 # Default spread
# Weights
net_debt = max((total_debt or 0) - (cash or 0), 0)
total_value = market_cap + net_debt
if total_value > 0:
weight_equity = market_cap / total_value
weight_debt = net_debt / total_value
# Tax shield (assume 25% corporate tax rate)
wacc = (weight_equity * cost_of_equity) + (weight_debt * cost_of_debt * 0.75)
else:
wacc = cost_of_equity
return min(max(wacc, 0.06), 0.20) # Floor 6%, cap 20%
def calculate_fcf_volatility(fcf_history: list[float]) -> float:
if len(fcf_history) < 3:
return 0.5 # Default moderate volatility
# Filter out zeros and negatives for volatility calc
positive_fcf = [fcf for fcf in fcf_history if fcf > 0]
if len(positive_fcf) < 2:
return 0.8 # High volatility if mostly negative FCF
try:
mean_fcf = statistics.mean(positive_fcf)
std_fcf = statistics.stdev(positive_fcf)
return min(std_fcf / mean_fcf, 1.0) if mean_fcf > 0 else 0.8
except:
return 0.5
def calculate_enhanced_dcf_value(
fcf_history: list[float],
growth_metrics: dict,
wacc: float,
market_cap: float,
revenue_growth: float | None = None
) -> float:
if not fcf_history or fcf_history[0] <= 0:
return 0
# Analyze FCF trend and quality
fcf_current = fcf_history[0]
fcf_avg_3yr = sum(fcf_history[:3]) / min(3, len(fcf_history))
fcf_volatility = calculate_fcf_volatility(fcf_history)
# Stage 1: High Growth (Years 1-3)
# Use revenue growth but cap based on business maturity
high_growth = min(revenue_growth or 0.05, 0.25) if revenue_growth else 0.05
if market_cap > 50_000_000_000: # Large cap
high_growth = min(high_growth, 0.10)
# Stage 2: Transition (Years 4-7)
transition_growth = (high_growth + 0.03) / 2
# Stage 3: Terminal (steady state)
terminal_growth = min(0.03, high_growth * 0.6)
# Project FCF with stages
pv = 0
base_fcf = max(fcf_current, fcf_avg_3yr * 0.85) # Conservative base
# High growth stage
for year in range(1, 4):
fcf_projected = base_fcf * (1 + high_growth) ** year
pv += fcf_projected / (1 + wacc) ** year
# Transition stage
for year in range(4, 8):
transition_rate = transition_growth * (8 - year) / 4 # Declining
fcf_projected = base_fcf * (1 + high_growth) ** 3 * (1 + transition_rate) ** (year - 3)
pv += fcf_projected / (1 + wacc) ** year
# Terminal value
final_fcf = base_fcf * (1 + high_growth) ** 3 * (1 + transition_growth) ** 4
if wacc <= terminal_growth:
terminal_growth = wacc * 0.8 # Adjust if invalid
terminal_value = (final_fcf * (1 + terminal_growth)) / (wacc - terminal_growth)
pv_terminal = terminal_value / (1 + wacc) ** 7
# Quality adjustment based on FCF volatility
quality_factor = max(0.7, 1 - (fcf_volatility * 0.5))
return (pv + pv_terminal) * quality_factor
def calculate_dcf_scenarios(
fcf_history: list[float],
growth_metrics: dict,
wacc: float,
market_cap: float,
revenue_growth: float | None = None
) -> dict:
scenarios = {
'bear': {'growth_adj': 0.5, 'wacc_adj': 1.2, 'terminal_adj': 0.8},
'base': {'growth_adj': 1.0, 'wacc_adj': 1.0, 'terminal_adj': 1.0},
'bull': {'growth_adj': 1.5, 'wacc_adj': 0.9, 'terminal_adj': 1.2}
}
results = {}
base_revenue_growth = revenue_growth or 0.05
for scenario, adjustments in scenarios.items():
adjusted_revenue_growth = base_revenue_growth * adjustments['growth_adj']
adjusted_wacc = wacc * adjustments['wacc_adj']
results[scenario] = calculate_enhanced_dcf_value(
fcf_history=fcf_history,
growth_metrics=growth_metrics,
wacc=adjusted_wacc,
market_cap=market_cap,
revenue_growth=adjusted_revenue_growth
)
# Probability-weighted average
expected_value = (
results['bear'] * 0.2 +
results['base'] * 0.6 +
results['bull'] * 0.2
)
return {
'scenarios': results,
'expected_value': expected_value,
'range': results['bull'] - results['bear'],
'upside': results['bull'],
'downside': results['bear']
} | --- +++ @@ -19,6 +19,7 @@ )
def valuation_analyst_agent(state: AgentState, agent_id: str = "valuation_analyst_agent"):
+ """Run valuation across tickers and write signals back to `state`."""
data = state["data"]
end_date = data["end_date"]
@@ -232,6 +233,7 @@ margin_of_safety: float = 0.25,
num_years: int = 5,
) -> float:
+ """Buffett owner‑earnings valuation with margin‑of‑safety."""
if not all(isinstance(x, (int, float)) for x in [net_income, depreciation, capex, working_capital_change]):
return 0
@@ -261,6 +263,7 @@ terminal_growth_rate: float = 0.02,
num_years: int = 5,
) -> float:
+ """Classic DCF on FCF with constant growth and terminal value."""
if free_cash_flow is None or free_cash_flow <= 0:
return 0
@@ -278,6 +281,7 @@
def calculate_ev_ebitda_value(financial_metrics: list):
+ """Implied equity value via median EV/EBITDA multiple."""
if not financial_metrics:
return 0
m0 = financial_metrics[0]
@@ -304,6 +308,7 @@ terminal_growth_rate: float = 0.03,
num_years: int = 5,
):
+ """Residual Income Model (Edwards‑Bell‑Ohlson)."""
if not (market_cap and net_income and price_to_book_ratio and price_to_book_ratio > 0):
return 0
@@ -340,6 +345,7 @@ risk_free_rate: float = 0.045,
market_risk_premium: float = 0.06
) -> float:
+ """Calculate WACC using available financial data."""
# Cost of Equity (CAPM)
cost_of_equity = risk_free_rate + beta_proxy * market_risk_premium
@@ -368,6 +374,7 @@
def calculate_fcf_volatility(fcf_history: list[float]) -> float:
+ """Calculate FCF volatility as coefficient of variation."""
if len(fcf_history) < 3:
return 0.5 # Default moderate volatility
@@ -391,6 +398,7 @@ market_cap: float,
revenue_growth: float | None = None
) -> float:
+ """Enhanced DCF with multi-stage growth."""
if not fcf_history or fcf_history[0] <= 0:
return 0
@@ -447,6 +455,7 @@ market_cap: float,
revenue_growth: float | None = None
) -> dict:
+ """Calculate DCF under multiple scenarios."""
scenarios = {
'bear': {'growth_adj': 0.5, 'wacc_adj': 1.2, 'terminal_adj': 0.8},
@@ -482,4 +491,4 @@ 'range': results['bull'] - results['bear'],
'upside': results['bull'],
'downside': results['bear']
- }+ }
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/valuation.py |
Expand my code with proper documentation strings | from typing import Dict, Optional, Any, Literal
from pydantic import BaseModel
class BaseEvent(BaseModel):
type: str
def to_sse(self) -> str:
event_type = self.type.lower()
return f"event: {event_type}\ndata: {self.model_dump_json()}\n\n"
class StartEvent(BaseEvent):
type: Literal["start"] = "start"
timestamp: Optional[str] = None
class ProgressUpdateEvent(BaseEvent):
type: Literal["progress"] = "progress"
agent: str
ticker: Optional[str] = None
status: str
timestamp: Optional[str] = None
analysis: Optional[str] = None
class ErrorEvent(BaseEvent):
type: Literal["error"] = "error"
message: str
timestamp: Optional[str] = None
class CompleteEvent(BaseEvent):
type: Literal["complete"] = "complete"
data: Dict[str, Any]
timestamp: Optional[str] = None | --- +++ @@ -3,20 +3,24 @@
class BaseEvent(BaseModel):
+ """Base class for all Server-Sent Event events"""
type: str
def to_sse(self) -> str:
+ """Convert to Server-Sent Event format"""
event_type = self.type.lower()
return f"event: {event_type}\ndata: {self.model_dump_json()}\n\n"
class StartEvent(BaseEvent):
+ """Event indicating the start of processing"""
type: Literal["start"] = "start"
timestamp: Optional[str] = None
class ProgressUpdateEvent(BaseEvent):
+ """Event containing an agent's progress update"""
type: Literal["progress"] = "progress"
agent: str
@@ -26,6 +30,7 @@ analysis: Optional[str] = None
class ErrorEvent(BaseEvent):
+ """Event indicating an error occurred"""
type: Literal["error"] = "error"
message: str
@@ -33,7 +38,8 @@
class CompleteEvent(BaseEvent):
+ """Event indicating successful completion with results"""
type: Literal["complete"] = "complete"
data: Dict[str, Any]
- timestamp: Optional[str] = None+ timestamp: Optional[str] = None
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/models/events.py |
Create structured documentation for my script | import sys
from dotenv import load_dotenv
from langchain_core.messages import HumanMessage
from langgraph.graph import END, StateGraph
from colorama import Fore, Style, init
import questionary
from src.agents.portfolio_manager import portfolio_management_agent
from src.agents.risk_manager import risk_management_agent
from src.graph.state import AgentState
from src.utils.display import print_trading_output
from src.utils.analysts import ANALYST_ORDER, get_analyst_nodes
from src.utils.progress import progress
from src.utils.visualize import save_graph_as_png
from src.cli.input import (
parse_cli_inputs,
)
import argparse
from datetime import datetime
from dateutil.relativedelta import relativedelta
import json
# Load environment variables from .env file
load_dotenv()
init(autoreset=True)
def parse_hedge_fund_response(response):
try:
return json.loads(response)
except json.JSONDecodeError as e:
print(f"JSON decoding error: {e}\nResponse: {repr(response)}")
return None
except TypeError as e:
print(f"Invalid response type (expected string, got {type(response).__name__}): {e}")
return None
except Exception as e:
print(f"Unexpected error while parsing response: {e}\nResponse: {repr(response)}")
return None
##### Run the Hedge Fund #####
def run_hedge_fund(
tickers: list[str],
start_date: str,
end_date: str,
portfolio: dict,
show_reasoning: bool = False,
selected_analysts: list[str] = [],
model_name: str = "gpt-4.1",
model_provider: str = "OpenAI",
):
# Start progress tracking
progress.start()
try:
# Build workflow (default to all analysts when none provided)
workflow = create_workflow(selected_analysts if selected_analysts else None)
agent = workflow.compile()
final_state = agent.invoke(
{
"messages": [
HumanMessage(
content="Make trading decisions based on the provided data.",
)
],
"data": {
"tickers": tickers,
"portfolio": portfolio,
"start_date": start_date,
"end_date": end_date,
"analyst_signals": {},
},
"metadata": {
"show_reasoning": show_reasoning,
"model_name": model_name,
"model_provider": model_provider,
},
},
)
return {
"decisions": parse_hedge_fund_response(final_state["messages"][-1].content),
"analyst_signals": final_state["data"]["analyst_signals"],
}
finally:
# Stop progress tracking
progress.stop()
def start(state: AgentState):
return state
def create_workflow(selected_analysts=None):
workflow = StateGraph(AgentState)
workflow.add_node("start_node", start)
# Get analyst nodes from the configuration
analyst_nodes = get_analyst_nodes()
# Default to all analysts if none selected
if selected_analysts is None:
selected_analysts = list(analyst_nodes.keys())
# Add selected analyst nodes
for analyst_key in selected_analysts:
node_name, node_func = analyst_nodes[analyst_key]
workflow.add_node(node_name, node_func)
workflow.add_edge("start_node", node_name)
# Always add risk and portfolio management
workflow.add_node("risk_management_agent", risk_management_agent)
workflow.add_node("portfolio_manager", portfolio_management_agent)
# Connect selected analysts to risk management
for analyst_key in selected_analysts:
node_name = analyst_nodes[analyst_key][0]
workflow.add_edge(node_name, "risk_management_agent")
workflow.add_edge("risk_management_agent", "portfolio_manager")
workflow.add_edge("portfolio_manager", END)
workflow.set_entry_point("start_node")
return workflow
if __name__ == "__main__":
inputs = parse_cli_inputs(
description="Run the hedge fund trading system",
require_tickers=True,
default_months_back=None,
include_graph_flag=True,
include_reasoning_flag=True,
)
tickers = inputs.tickers
selected_analysts = inputs.selected_analysts
# Construct portfolio here
portfolio = {
"cash": inputs.initial_cash,
"margin_requirement": inputs.margin_requirement,
"margin_used": 0.0,
"positions": {
ticker: {
"long": 0,
"short": 0,
"long_cost_basis": 0.0,
"short_cost_basis": 0.0,
"short_margin_used": 0.0,
}
for ticker in tickers
},
"realized_gains": {
ticker: {
"long": 0.0,
"short": 0.0,
}
for ticker in tickers
},
}
result = run_hedge_fund(
tickers=tickers,
start_date=inputs.start_date,
end_date=inputs.end_date,
portfolio=portfolio,
show_reasoning=inputs.show_reasoning,
selected_analysts=inputs.selected_analysts,
model_name=inputs.model_name,
model_provider=inputs.model_provider,
)
print_trading_output(result) | --- +++ @@ -28,6 +28,7 @@
def parse_hedge_fund_response(response):
+ """Parses a JSON string and returns a dictionary."""
try:
return json.loads(response)
except json.JSONDecodeError as e:
@@ -92,10 +93,12 @@
def start(state: AgentState):
+ """Initialize the workflow with the input message."""
return state
def create_workflow(selected_analysts=None):
+ """Create the workflow with selected analysts."""
workflow = StateGraph(AgentState)
workflow.add_node("start_node", start)
@@ -173,4 +176,4 @@ model_name=inputs.model_name,
model_provider=inputs.model_provider,
)
- print_trading_output(result)+ print_trading_output(result)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/main.py |
Generate docstrings for script automation |
import platform
import subprocess
import requests
import time
from typing import List
import questionary
from colorama import Fore, Style
import os
from . import docker
# Constants
DEFAULT_OLLAMA_SERVER_URL = "http://localhost:11434"
def _get_ollama_base_url() -> str:
url = os.environ.get("OLLAMA_BASE_URL", DEFAULT_OLLAMA_SERVER_URL)
if not url:
url = DEFAULT_OLLAMA_SERVER_URL
return url.rstrip("/")
def _get_ollama_endpoint(path: str) -> str:
base = _get_ollama_base_url()
if not path.startswith("/"):
path = f"/{path}"
return f"{base}{path}"
OLLAMA_DOWNLOAD_URL = {"darwin": "https://ollama.com/download/darwin", "windows": "https://ollama.com/download/windows", "linux": "https://ollama.com/download/linux"} # macOS # Windows # Linux
INSTALLATION_INSTRUCTIONS = {"darwin": "curl -fsSL https://ollama.com/install.sh | sh", "windows": "# Download from https://ollama.com/download/windows and run the installer", "linux": "curl -fsSL https://ollama.com/install.sh | sh"}
def is_ollama_installed() -> bool:
system = platform.system().lower()
if system == "darwin" or system == "linux": # macOS or Linux
try:
result = subprocess.run(["which", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
return result.returncode == 0
except Exception:
return False
elif system == "windows": # Windows
try:
result = subprocess.run(["where", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
return result.returncode == 0
except Exception:
return False
else:
return False # Unsupported OS
def is_ollama_server_running() -> bool:
endpoint = _get_ollama_endpoint("/api/tags")
try:
response = requests.get(endpoint, timeout=2)
return response.status_code == 200
except requests.RequestException:
return False
def get_locally_available_models() -> List[str]:
if not is_ollama_server_running():
return []
try:
endpoint = _get_ollama_endpoint("/api/tags")
response = requests.get(endpoint, timeout=5)
if response.status_code == 200:
data = response.json()
return [model["name"] for model in data["models"]] if "models" in data else []
return []
except requests.RequestException:
return []
def start_ollama_server() -> bool:
if is_ollama_server_running():
print(f"{Fore.GREEN}Ollama server is already running.{Style.RESET_ALL}")
return True
system = platform.system().lower()
try:
if system == "darwin" or system == "linux": # macOS or Linux
subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
elif system == "windows": # Windows
subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
else:
print(f"{Fore.RED}Unsupported operating system: {system}{Style.RESET_ALL}")
return False
# Wait for server to start
for _ in range(10): # Try for 10 seconds
if is_ollama_server_running():
print(f"{Fore.GREEN}Ollama server started successfully.{Style.RESET_ALL}")
return True
time.sleep(1)
print(f"{Fore.RED}Failed to start Ollama server. Timed out waiting for server to become available.{Style.RESET_ALL}")
return False
except Exception as e:
print(f"{Fore.RED}Error starting Ollama server: {e}{Style.RESET_ALL}")
return False
def install_ollama() -> bool:
system = platform.system().lower()
if system not in OLLAMA_DOWNLOAD_URL:
print(f"{Fore.RED}Unsupported operating system for automatic installation: {system}{Style.RESET_ALL}")
print(f"Please visit https://ollama.com/download to install Ollama manually.")
return False
if system == "darwin": # macOS
print(f"{Fore.YELLOW}Ollama for Mac is available as an application download.{Style.RESET_ALL}")
# Default to offering the app download first for macOS users
if questionary.confirm("Would you like to download the Ollama application?", default=True).ask():
try:
import webbrowser
webbrowser.open(OLLAMA_DOWNLOAD_URL["darwin"])
print(f"{Fore.YELLOW}Please download and install the application, then restart this program.{Style.RESET_ALL}")
print(f"{Fore.CYAN}After installation, you may need to open the Ollama app once before continuing.{Style.RESET_ALL}")
# Ask if they want to try continuing after installation
if questionary.confirm("Have you installed the Ollama app and opened it at least once?", default=False).ask():
# Check if it's now installed
if is_ollama_installed() and start_ollama_server():
print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")
return False
return False
except Exception as e:
print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")
return False
else:
# Only offer command-line installation as a fallback for advanced users
if questionary.confirm("Would you like to try the command-line installation instead? (For advanced users)", default=False).ask():
print(f"{Fore.YELLOW}Attempting command-line installation...{Style.RESET_ALL}")
try:
install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if install_process.returncode == 0:
print(f"{Fore.GREEN}Ollama installed successfully via command line.{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Command-line installation failed. Please use the app download method instead.{Style.RESET_ALL}")
return False
except Exception as e:
print(f"{Fore.RED}Error during command-line installation: {e}{Style.RESET_ALL}")
return False
return False
elif system == "linux": # Linux
print(f"{Fore.YELLOW}Installing Ollama...{Style.RESET_ALL}")
try:
# Run the installation command as a single command
install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if install_process.returncode == 0:
print(f"{Fore.GREEN}Ollama installed successfully.{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Failed to install Ollama. Error: {install_process.stderr}{Style.RESET_ALL}")
return False
except Exception as e:
print(f"{Fore.RED}Error during Ollama installation: {e}{Style.RESET_ALL}")
return False
elif system == "windows": # Windows
print(f"{Fore.YELLOW}Automatic installation on Windows is not supported.{Style.RESET_ALL}")
print(f"Please download and install Ollama from: {OLLAMA_DOWNLOAD_URL['windows']}")
# Ask if they want to open the download page
if questionary.confirm("Do you want to open the Ollama download page in your browser?").ask():
try:
import webbrowser
webbrowser.open(OLLAMA_DOWNLOAD_URL["windows"])
print(f"{Fore.YELLOW}After installation, please restart this application.{Style.RESET_ALL}")
# Ask if they want to try continuing after installation
if questionary.confirm("Have you installed Ollama?", default=False).ask():
# Check if it's now installed
if is_ollama_installed() and start_ollama_server():
print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")
return False
except Exception as e:
print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")
return False
return False
def download_model(model_name: str) -> bool:
if not is_ollama_server_running():
if not start_ollama_server():
return False
print(f"{Fore.YELLOW}Downloading model {model_name}...{Style.RESET_ALL}")
print(f"{Fore.CYAN}This may take a while depending on your internet speed and the model size.{Style.RESET_ALL}")
print(f"{Fore.CYAN}The download is happening in the background. Please be patient...{Style.RESET_ALL}")
try:
# Use the Ollama CLI to download the model
process = subprocess.Popen(
["ollama", "pull", model_name],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, # Redirect stderr to stdout to capture all output
text=True,
bufsize=1, # Line buffered
encoding='utf-8', # Explicitly use UTF-8 encoding
errors='replace' # Replace any characters that cannot be decoded
)
# Show some progress to the user
print(f"{Fore.CYAN}Download progress:{Style.RESET_ALL}")
# For tracking progress
last_percentage = 0
last_phase = ""
bar_length = 40
while True:
output = process.stdout.readline()
if output == "" and process.poll() is not None:
break
if output:
output = output.strip()
# Try to extract percentage information using a more lenient approach
percentage = None
current_phase = None
# Example patterns in Ollama output:
# "downloading: 23.45 MB / 42.19 MB [================>-------------] 55.59%"
# "downloading model: 76%"
# "pulling manifest: 100%"
# Check for percentage in the output
import re
percentage_match = re.search(r"(\d+(\.\d+)?)%", output)
if percentage_match:
try:
percentage = float(percentage_match.group(1))
except ValueError:
percentage = None
# Try to determine the current phase (downloading, extracting, etc.)
phase_match = re.search(r"^([a-zA-Z\s]+):", output)
if phase_match:
current_phase = phase_match.group(1).strip()
# If we found a percentage, display a progress bar
if percentage is not None:
# Only update if there's a significant change (avoid flickering)
if abs(percentage - last_percentage) >= 1 or (current_phase and current_phase != last_phase):
last_percentage = percentage
if current_phase:
last_phase = current_phase
# Create a progress bar
filled_length = int(bar_length * percentage / 100)
bar = "█" * filled_length + "░" * (bar_length - filled_length)
# Build the status line with the phase if available
phase_display = f"{Fore.CYAN}{last_phase.capitalize()}{Style.RESET_ALL}: " if last_phase else ""
status_line = f"\r{phase_display}{Fore.GREEN}{bar}{Style.RESET_ALL} {Fore.YELLOW}{percentage:.1f}%{Style.RESET_ALL}"
# Print the status line without a newline to update in place
print(status_line, end="", flush=True)
else:
# If we couldn't extract a percentage but have identifiable output
if "download" in output.lower() or "extract" in output.lower() or "pulling" in output.lower():
# Don't print a newline for percentage updates
if "%" in output:
print(f"\r{Fore.GREEN}{output}{Style.RESET_ALL}", end="", flush=True)
else:
print(f"{Fore.GREEN}{output}{Style.RESET_ALL}")
# Wait for the process to finish
return_code = process.wait()
# Ensure we print a newline after the progress bar
print()
if return_code == 0:
print(f"{Fore.GREEN}Model {model_name} downloaded successfully!{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Failed to download model {model_name}. Check your internet connection and try again.{Style.RESET_ALL}")
return False
except Exception as e:
print(f"\n{Fore.RED}Error downloading model {model_name}: {e}{Style.RESET_ALL}")
return False
def ensure_ollama_and_model(model_name: str) -> bool:
ollama_url = _get_ollama_base_url()
env_override = os.environ.get("OLLAMA_BASE_URL")
# If an explicit base URL is provided (including Docker defaults), use the remote workflow
if env_override or ollama_url.startswith("http://ollama:") or ollama_url.startswith("http://host.docker.internal:"):
return docker.ensure_ollama_and_model(model_name, ollama_url)
# Regular flow for environments that rely on the local Ollama install
# Check if Ollama is installed
if not is_ollama_installed():
print(f"{Fore.YELLOW}Ollama is not installed on your system.{Style.RESET_ALL}")
# Ask if they want to install it
if questionary.confirm("Do you want to install Ollama?").ask():
if not install_ollama():
return False
else:
print(f"{Fore.RED}Ollama is required to use local models.{Style.RESET_ALL}")
return False
# Make sure the server is running
if not is_ollama_server_running():
print(f"{Fore.YELLOW}Starting Ollama server...{Style.RESET_ALL}")
if not start_ollama_server():
return False
# Check if the model is already downloaded
available_models = get_locally_available_models()
if model_name not in available_models:
print(f"{Fore.YELLOW}Model {model_name} is not available locally.{Style.RESET_ALL}")
# Ask if they want to download it
model_size_info = ""
if "70b" in model_name:
model_size_info = " This is a large model (up to several GB) and may take a while to download."
elif "34b" in model_name or "8x7b" in model_name:
model_size_info = " This is a medium-sized model (1-2 GB) and may take a few minutes to download."
if questionary.confirm(f"Do you want to download the {model_name} model?{model_size_info} The download will happen in the background.").ask():
return download_model(model_name)
else:
print(f"{Fore.RED}The model is required to proceed.{Style.RESET_ALL}")
return False
return True
def delete_model(model_name: str) -> bool:
# Check if we're running in Docker
in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")
# In Docker environment, delegate to docker module
if in_docker:
ollama_url = os.environ.get("OLLAMA_BASE_URL", "http://ollama:11434")
return docker.delete_model(model_name, ollama_url)
# Non-Docker environment
if not is_ollama_server_running():
if not start_ollama_server():
return False
print(f"{Fore.YELLOW}Deleting model {model_name}...{Style.RESET_ALL}")
try:
# Use the Ollama CLI to delete the model
process = subprocess.run(["ollama", "rm", model_name], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if process.returncode == 0:
print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Failed to delete model {model_name}. Error: {process.stderr}{Style.RESET_ALL}")
return False
except Exception as e:
print(f"{Fore.RED}Error deleting model {model_name}: {e}{Style.RESET_ALL}")
return False
# Add this at the end of the file for command-line usage
if __name__ == "__main__":
import sys
import argparse
parser = argparse.ArgumentParser(description="Ollama model manager")
parser.add_argument("--check-model", help="Check if model exists and download if needed")
args = parser.parse_args()
if args.check_model:
print(f"Ensuring Ollama is installed and model {args.check_model} is available...")
result = ensure_ollama_and_model(args.check_model)
sys.exit(0 if result else 1)
else:
print("No action specified. Use --check-model to check if a model exists.")
sys.exit(1) | --- +++ @@ -1,3 +1,4 @@+"""Utilities for working with Ollama models"""
import platform
import subprocess
@@ -14,6 +15,7 @@
def _get_ollama_base_url() -> str:
+ """Return the configured Ollama base URL, trimming any trailing slash."""
url = os.environ.get("OLLAMA_BASE_URL", DEFAULT_OLLAMA_SERVER_URL)
if not url:
url = DEFAULT_OLLAMA_SERVER_URL
@@ -21,6 +23,7 @@
def _get_ollama_endpoint(path: str) -> str:
+ """Build a full Ollama API endpoint from the configured base URL."""
base = _get_ollama_base_url()
if not path.startswith("/"):
path = f"/{path}"
@@ -32,6 +35,7 @@
def is_ollama_installed() -> bool:
+ """Check if Ollama is installed on the system."""
system = platform.system().lower()
if system == "darwin" or system == "linux": # macOS or Linux
@@ -51,6 +55,7 @@
def is_ollama_server_running() -> bool:
+ """Check if the Ollama server is running."""
endpoint = _get_ollama_endpoint("/api/tags")
try:
response = requests.get(endpoint, timeout=2)
@@ -60,6 +65,7 @@
def get_locally_available_models() -> List[str]:
+ """Get a list of models that are already downloaded locally."""
if not is_ollama_server_running():
return []
@@ -75,6 +81,7 @@
def start_ollama_server() -> bool:
+ """Start the Ollama server if it's not already running."""
if is_ollama_server_running():
print(f"{Fore.GREEN}Ollama server is already running.{Style.RESET_ALL}")
return True
@@ -105,6 +112,7 @@
def install_ollama() -> bool:
+ """Install Ollama on the system."""
system = platform.system().lower()
if system not in OLLAMA_DOWNLOAD_URL:
print(f"{Fore.RED}Unsupported operating system for automatic installation: {system}{Style.RESET_ALL}")
@@ -197,6 +205,7 @@
def download_model(model_name: str) -> bool:
+ """Download an Ollama model."""
if not is_ollama_server_running():
if not start_ollama_server():
return False
@@ -300,6 +309,7 @@
def ensure_ollama_and_model(model_name: str) -> bool:
+ """Ensure Ollama is installed, running, and the requested model is available."""
ollama_url = _get_ollama_base_url()
env_override = os.environ.get("OLLAMA_BASE_URL")
@@ -348,6 +358,7 @@
def delete_model(model_name: str) -> bool:
+ """Delete a locally downloaded Ollama model."""
# Check if we're running in Docker
in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")
@@ -393,4 +404,4 @@ sys.exit(0 if result else 1)
else:
print("No action specified. Use --check-model to check if a model exists.")
- sys.exit(1)+ sys.exit(1)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/utils/ollama.py |
Generate NumPy-style docstrings | from src.graph.state import AgentState, show_agent_reasoning
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel, Field
import json
from typing_extensions import Literal
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from src.utils.llm import call_llm
from src.utils.progress import progress
from src.utils.api_key import get_api_key_from_state
class WarrenBuffettSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: int = Field(description="Confidence 0-100")
reasoning: str = Field(description="Reasoning for the decision")
def warren_buffett_agent(state: AgentState, agent_id: str = "warren_buffett_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
# Collect all analysis for LLM reasoning
analysis_data = {}
buffett_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
# Fetch required data - request more periods for better trend analysis
metrics = get_financial_metrics(ticker, end_date, period="ttm", limit=10, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
financial_line_items = search_line_items(
ticker,
[
"capital_expenditure",
"depreciation_and_amortization",
"net_income",
"outstanding_shares",
"total_assets",
"total_liabilities",
"shareholders_equity",
"dividends_and_other_cash_distributions",
"issuance_or_purchase_of_equity_shares",
"gross_profit",
"revenue",
"free_cash_flow",
],
end_date,
period="ttm",
limit=10,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
# Get current market cap
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing fundamentals")
# Analyze fundamentals
fundamental_analysis = analyze_fundamentals(metrics)
progress.update_status(agent_id, ticker, "Analyzing consistency")
consistency_analysis = analyze_consistency(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing competitive moat")
moat_analysis = analyze_moat(metrics)
progress.update_status(agent_id, ticker, "Analyzing pricing power")
pricing_power_analysis = analyze_pricing_power(financial_line_items, metrics)
progress.update_status(agent_id, ticker, "Analyzing book value growth")
book_value_analysis = analyze_book_value_growth(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing management quality")
mgmt_analysis = analyze_management_quality(financial_line_items)
progress.update_status(agent_id, ticker, "Calculating intrinsic value")
intrinsic_value_analysis = calculate_intrinsic_value(financial_line_items)
# Calculate total score without circle of competence (LLM will handle that)
total_score = (
fundamental_analysis["score"] +
consistency_analysis["score"] +
moat_analysis["score"] +
mgmt_analysis["score"] +
pricing_power_analysis["score"] +
book_value_analysis["score"]
)
# Update max possible score calculation
max_possible_score = (
10 + # fundamental_analysis (ROE, debt, margins, current ratio)
moat_analysis["max_score"] +
mgmt_analysis["max_score"] +
5 + # pricing_power (0-5)
5 # book_value_growth (0-5)
)
# Add margin of safety analysis if we have both intrinsic value and current price
margin_of_safety = None
intrinsic_value = intrinsic_value_analysis["intrinsic_value"]
if intrinsic_value and market_cap:
margin_of_safety = (intrinsic_value - market_cap) / market_cap
# Combine all analysis results for LLM evaluation
analysis_data[ticker] = {
"ticker": ticker,
"score": total_score,
"max_score": max_possible_score,
"fundamental_analysis": fundamental_analysis,
"consistency_analysis": consistency_analysis,
"moat_analysis": moat_analysis,
"pricing_power_analysis": pricing_power_analysis,
"book_value_analysis": book_value_analysis,
"management_analysis": mgmt_analysis,
"intrinsic_value_analysis": intrinsic_value_analysis,
"market_cap": market_cap,
"margin_of_safety": margin_of_safety,
}
progress.update_status(agent_id, ticker, "Generating Warren Buffett analysis")
buffett_output = generate_buffett_output(
ticker=ticker,
analysis_data=analysis_data[ticker],
state=state,
agent_id=agent_id,
)
# Store analysis in consistent format with other agents
buffett_analysis[ticker] = {
"signal": buffett_output.signal,
"confidence": buffett_output.confidence,
"reasoning": buffett_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=buffett_output.reasoning)
# Create the message
message = HumanMessage(content=json.dumps(buffett_analysis), name=agent_id)
# Show reasoning if requested
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(buffett_analysis, agent_id)
# Add the signal to the analyst_signals list
state["data"]["analyst_signals"][agent_id] = buffett_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_fundamentals(metrics: list) -> dict[str, any]:
if not metrics:
return {"score": 0, "details": "Insufficient fundamental data"}
latest_metrics = metrics[0]
score = 0
reasoning = []
# Check ROE (Return on Equity)
if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15: # 15% ROE threshold
score += 2
reasoning.append(f"Strong ROE of {latest_metrics.return_on_equity:.1%}")
elif latest_metrics.return_on_equity:
reasoning.append(f"Weak ROE of {latest_metrics.return_on_equity:.1%}")
else:
reasoning.append("ROE data not available")
# Check Debt to Equity
if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity < 0.5:
score += 2
reasoning.append("Conservative debt levels")
elif latest_metrics.debt_to_equity:
reasoning.append(f"High debt to equity ratio of {latest_metrics.debt_to_equity:.1f}")
else:
reasoning.append("Debt to equity data not available")
# Check Operating Margin
if latest_metrics.operating_margin and latest_metrics.operating_margin > 0.15:
score += 2
reasoning.append("Strong operating margins")
elif latest_metrics.operating_margin:
reasoning.append(f"Weak operating margin of {latest_metrics.operating_margin:.1%}")
else:
reasoning.append("Operating margin data not available")
# Check Current Ratio
if latest_metrics.current_ratio and latest_metrics.current_ratio > 1.5:
score += 1
reasoning.append("Good liquidity position")
elif latest_metrics.current_ratio:
reasoning.append(f"Weak liquidity with current ratio of {latest_metrics.current_ratio:.1f}")
else:
reasoning.append("Current ratio data not available")
return {"score": score, "details": "; ".join(reasoning), "metrics": latest_metrics.model_dump()}
def analyze_consistency(financial_line_items: list) -> dict[str, any]:
if len(financial_line_items) < 4: # Need at least 4 periods for trend analysis
return {"score": 0, "details": "Insufficient historical data"}
score = 0
reasoning = []
# Check earnings growth trend
earnings_values = [item.net_income for item in financial_line_items if item.net_income]
if len(earnings_values) >= 4:
# Simple check: is each period's earnings bigger than the next?
earnings_growth = all(earnings_values[i] > earnings_values[i + 1] for i in range(len(earnings_values) - 1))
if earnings_growth:
score += 3
reasoning.append("Consistent earnings growth over past periods")
else:
reasoning.append("Inconsistent earnings growth pattern")
# Calculate total growth rate from oldest to latest
if len(earnings_values) >= 2 and earnings_values[-1] != 0:
growth_rate = (earnings_values[0] - earnings_values[-1]) / abs(earnings_values[-1])
reasoning.append(f"Total earnings growth of {growth_rate:.1%} over past {len(earnings_values)} periods")
else:
reasoning.append("Insufficient earnings data for trend analysis")
return {
"score": score,
"details": "; ".join(reasoning),
}
def analyze_moat(metrics: list) -> dict[str, any]:
if not metrics or len(metrics) < 5: # Need more data for proper moat analysis
return {"score": 0, "max_score": 5, "details": "Insufficient data for comprehensive moat analysis"}
reasoning = []
moat_score = 0
max_score = 5
# 1. Return on Capital Consistency (Buffett's favorite moat indicator)
historical_roes = [m.return_on_equity for m in metrics if m.return_on_equity is not None]
historical_roics = [m.return_on_invested_capital for m in metrics if
hasattr(m, 'return_on_invested_capital') and m.return_on_invested_capital is not None]
if len(historical_roes) >= 5:
# Check for consistently high ROE (>15% for most periods)
high_roe_periods = sum(1 for roe in historical_roes if roe > 0.15)
roe_consistency = high_roe_periods / len(historical_roes)
if roe_consistency >= 0.8: # 80%+ of periods with ROE > 15%
moat_score += 2
avg_roe = sum(historical_roes) / len(historical_roes)
reasoning.append(
f"Excellent ROE consistency: {high_roe_periods}/{len(historical_roes)} periods >15% (avg: {avg_roe:.1%}) - indicates durable competitive advantage")
elif roe_consistency >= 0.6:
moat_score += 1
reasoning.append(f"Good ROE performance: {high_roe_periods}/{len(historical_roes)} periods >15%")
else:
reasoning.append(f"Inconsistent ROE: only {high_roe_periods}/{len(historical_roes)} periods >15%")
else:
reasoning.append("Insufficient ROE history for moat analysis")
# 2. Operating Margin Stability (Pricing Power Indicator)
historical_margins = [m.operating_margin for m in metrics if m.operating_margin is not None]
if len(historical_margins) >= 5:
# Check for stable or improving margins (sign of pricing power)
avg_margin = sum(historical_margins) / len(historical_margins)
recent_margins = historical_margins[:3] # Last 3 periods
older_margins = historical_margins[-3:] # First 3 periods
recent_avg = sum(recent_margins) / len(recent_margins)
older_avg = sum(older_margins) / len(older_margins)
if avg_margin > 0.2 and recent_avg >= older_avg: # 20%+ margins and stable/improving
moat_score += 1
reasoning.append(f"Strong and stable operating margins (avg: {avg_margin:.1%}) indicate pricing power moat")
elif avg_margin > 0.15: # At least decent margins
reasoning.append(f"Decent operating margins (avg: {avg_margin:.1%}) suggest some competitive advantage")
else:
reasoning.append(f"Low operating margins (avg: {avg_margin:.1%}) suggest limited pricing power")
# 3. Asset Efficiency and Scale Advantages
if len(metrics) >= 5:
# Check asset turnover trends (revenue efficiency)
asset_turnovers = []
for m in metrics:
if hasattr(m, 'asset_turnover') and m.asset_turnover is not None:
asset_turnovers.append(m.asset_turnover)
if len(asset_turnovers) >= 3:
if any(turnover > 1.0 for turnover in asset_turnovers): # Efficient asset use
moat_score += 1
reasoning.append("Efficient asset utilization suggests operational moat")
# 4. Competitive Position Strength (inferred from trend stability)
if len(historical_roes) >= 5 and len(historical_margins) >= 5:
# Calculate coefficient of variation (stability measure)
roe_avg = sum(historical_roes) / len(historical_roes)
roe_variance = sum((roe - roe_avg) ** 2 for roe in historical_roes) / len(historical_roes)
roe_stability = 1 - (roe_variance ** 0.5) / roe_avg if roe_avg > 0 else 0
margin_avg = sum(historical_margins) / len(historical_margins)
margin_variance = sum((margin - margin_avg) ** 2 for margin in historical_margins) / len(historical_margins)
margin_stability = 1 - (margin_variance ** 0.5) / margin_avg if margin_avg > 0 else 0
overall_stability = (roe_stability + margin_stability) / 2
if overall_stability > 0.7: # High stability indicates strong competitive position
moat_score += 1
reasoning.append(f"High performance stability ({overall_stability:.1%}) suggests strong competitive moat")
# Cap the score at max_score
moat_score = min(moat_score, max_score)
return {
"score": moat_score,
"max_score": max_score,
"details": "; ".join(reasoning) if reasoning else "Limited moat analysis available",
}
def analyze_management_quality(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "max_score": 2, "details": "Insufficient data for management analysis"}
reasoning = []
mgmt_score = 0
latest = financial_line_items[0]
if hasattr(latest,
"issuance_or_purchase_of_equity_shares") and latest.issuance_or_purchase_of_equity_shares and latest.issuance_or_purchase_of_equity_shares < 0:
# Negative means the company spent money on buybacks
mgmt_score += 1
reasoning.append("Company has been repurchasing shares (shareholder-friendly)")
if hasattr(latest,
"issuance_or_purchase_of_equity_shares") and latest.issuance_or_purchase_of_equity_shares and latest.issuance_or_purchase_of_equity_shares > 0:
# Positive issuance means new shares => possible dilution
reasoning.append("Recent common stock issuance (potential dilution)")
else:
reasoning.append("No significant new stock issuance detected")
# Check for any dividends
if hasattr(latest,
"dividends_and_other_cash_distributions") and latest.dividends_and_other_cash_distributions and latest.dividends_and_other_cash_distributions < 0:
mgmt_score += 1
reasoning.append("Company has a track record of paying dividends")
else:
reasoning.append("No or minimal dividends paid")
return {
"score": mgmt_score,
"max_score": 2,
"details": "; ".join(reasoning),
}
def calculate_owner_earnings(financial_line_items: list) -> dict[str, any]:
if not financial_line_items or len(financial_line_items) < 2:
return {"owner_earnings": None, "details": ["Insufficient data for owner earnings calculation"]}
latest = financial_line_items[0]
details = []
# Core components
net_income = latest.net_income
depreciation = latest.depreciation_and_amortization
capex = latest.capital_expenditure
if not all([net_income is not None, depreciation is not None, capex is not None]):
missing = []
if net_income is None: missing.append("net income")
if depreciation is None: missing.append("depreciation")
if capex is None: missing.append("capital expenditure")
return {"owner_earnings": None, "details": [f"Missing components: {', '.join(missing)}"]}
# Enhanced maintenance capex estimation using historical analysis
maintenance_capex = estimate_maintenance_capex(financial_line_items)
# Working capital change analysis (if data available)
working_capital_change = 0
if len(financial_line_items) >= 2:
try:
current_assets_current = getattr(latest, 'current_assets', None)
current_liab_current = getattr(latest, 'current_liabilities', None)
previous = financial_line_items[1]
current_assets_previous = getattr(previous, 'current_assets', None)
current_liab_previous = getattr(previous, 'current_liabilities', None)
if all([current_assets_current, current_liab_current, current_assets_previous, current_liab_previous]):
wc_current = current_assets_current - current_liab_current
wc_previous = current_assets_previous - current_liab_previous
working_capital_change = wc_current - wc_previous
details.append(f"Working capital change: ${working_capital_change:,.0f}")
except:
pass # Skip working capital adjustment if data unavailable
# Calculate owner earnings
owner_earnings = net_income + depreciation - maintenance_capex - working_capital_change
# Sanity checks
if owner_earnings < net_income * 0.3: # Owner earnings shouldn't be less than 30% of net income typically
details.append("Warning: Owner earnings significantly below net income - high capex intensity")
if maintenance_capex > depreciation * 2: # Maintenance capex shouldn't typically exceed 2x depreciation
details.append("Warning: Estimated maintenance capex seems high relative to depreciation")
details.extend([
f"Net income: ${net_income:,.0f}",
f"Depreciation: ${depreciation:,.0f}",
f"Estimated maintenance capex: ${maintenance_capex:,.0f}",
f"Owner earnings: ${owner_earnings:,.0f}"
])
return {
"owner_earnings": owner_earnings,
"components": {
"net_income": net_income,
"depreciation": depreciation,
"maintenance_capex": maintenance_capex,
"working_capital_change": working_capital_change,
"total_capex": abs(capex) if capex else 0
},
"details": details,
}
def estimate_maintenance_capex(financial_line_items: list) -> float:
if not financial_line_items:
return 0
# Approach 1: Historical average as % of revenue
capex_ratios = []
depreciation_values = []
for item in financial_line_items[:5]: # Last 5 periods
if hasattr(item, 'capital_expenditure') and hasattr(item, 'revenue'):
if item.capital_expenditure and item.revenue and item.revenue > 0:
capex_ratio = abs(item.capital_expenditure) / item.revenue
capex_ratios.append(capex_ratio)
if hasattr(item, 'depreciation_and_amortization') and item.depreciation_and_amortization:
depreciation_values.append(item.depreciation_and_amortization)
# Approach 2: Percentage of depreciation (typically 80-120% for maintenance)
latest_depreciation = financial_line_items[0].depreciation_and_amortization if financial_line_items[
0].depreciation_and_amortization else 0
# Approach 3: Industry-specific heuristics
latest_capex = abs(financial_line_items[0].capital_expenditure) if financial_line_items[
0].capital_expenditure else 0
# Conservative estimate: Use the higher of:
# 1. 85% of total capex (assuming 15% is growth capex)
# 2. 100% of depreciation (replacement of worn-out assets)
# 3. Historical average if stable
method_1 = latest_capex * 0.85 # 85% of total capex
method_2 = latest_depreciation # 100% of depreciation
# If we have historical data, use average capex ratio
if len(capex_ratios) >= 3:
avg_capex_ratio = sum(capex_ratios) / len(capex_ratios)
latest_revenue = financial_line_items[0].revenue if hasattr(financial_line_items[0], 'revenue') and \
financial_line_items[0].revenue else 0
method_3 = avg_capex_ratio * latest_revenue if latest_revenue else 0
# Use the median of the three approaches for conservatism
estimates = sorted([method_1, method_2, method_3])
return estimates[1] # Median
else:
# Use the higher of method 1 and 2
return max(method_1, method_2)
def calculate_intrinsic_value(financial_line_items: list) -> dict[str, any]:
if not financial_line_items or len(financial_line_items) < 3:
return {"intrinsic_value": None, "details": ["Insufficient data for reliable valuation"]}
# Calculate owner earnings with better methodology
earnings_data = calculate_owner_earnings(financial_line_items)
if not earnings_data["owner_earnings"]:
return {"intrinsic_value": None, "details": earnings_data["details"]}
owner_earnings = earnings_data["owner_earnings"]
latest_financial_line_items = financial_line_items[0]
shares_outstanding = latest_financial_line_items.outstanding_shares
if not shares_outstanding or shares_outstanding <= 0:
return {"intrinsic_value": None, "details": ["Missing or invalid shares outstanding data"]}
# Enhanced DCF with more realistic assumptions
details = []
# Estimate growth rate based on historical performance (more conservative)
historical_earnings = []
for item in financial_line_items[:5]: # Last 5 years
if hasattr(item, 'net_income') and item.net_income:
historical_earnings.append(item.net_income)
# Calculate historical growth rate
if len(historical_earnings) >= 3:
oldest_earnings = historical_earnings[-1]
latest_earnings = historical_earnings[0]
years = len(historical_earnings) - 1
if oldest_earnings > 0:
historical_growth = ((latest_earnings / oldest_earnings) ** (1 / years)) - 1
# Conservative adjustment - cap growth and apply haircut
historical_growth = max(-0.05, min(historical_growth, 0.15)) # Cap between -5% and 15%
conservative_growth = historical_growth * 0.7 # Apply 30% haircut for conservatism
else:
conservative_growth = 0.03 # Default 3% if negative base
else:
conservative_growth = 0.03 # Default conservative growth
# Buffett's conservative assumptions
stage1_growth = min(conservative_growth, 0.08) # Stage 1: cap at 8%
stage2_growth = min(conservative_growth * 0.5, 0.04) # Stage 2: half of stage 1, cap at 4%
terminal_growth = 0.025 # Long-term GDP growth rate
# Risk-adjusted discount rate based on business quality
base_discount_rate = 0.09 # Base 9%
# Adjust based on analysis scores (if available in calling context)
# For now, use conservative 10%
discount_rate = 0.10
# Three-stage DCF model
stage1_years = 5 # High growth phase
stage2_years = 5 # Transition phase
present_value = 0
details.append(
f"Using three-stage DCF: Stage 1 ({stage1_growth:.1%}, {stage1_years}y), Stage 2 ({stage2_growth:.1%}, {stage2_years}y), Terminal ({terminal_growth:.1%})")
# Stage 1: Higher growth
stage1_pv = 0
for year in range(1, stage1_years + 1):
future_earnings = owner_earnings * (1 + stage1_growth) ** year
pv = future_earnings / (1 + discount_rate) ** year
stage1_pv += pv
# Stage 2: Transition growth
stage2_pv = 0
stage1_final_earnings = owner_earnings * (1 + stage1_growth) ** stage1_years
for year in range(1, stage2_years + 1):
future_earnings = stage1_final_earnings * (1 + stage2_growth) ** year
pv = future_earnings / (1 + discount_rate) ** (stage1_years + year)
stage2_pv += pv
# Terminal value using Gordon Growth Model
final_earnings = stage1_final_earnings * (1 + stage2_growth) ** stage2_years
terminal_earnings = final_earnings * (1 + terminal_growth)
terminal_value = terminal_earnings / (discount_rate - terminal_growth)
terminal_pv = terminal_value / (1 + discount_rate) ** (stage1_years + stage2_years)
# Total intrinsic value
intrinsic_value = stage1_pv + stage2_pv + terminal_pv
# Apply additional margin of safety (Buffett's conservatism)
conservative_intrinsic_value = intrinsic_value * 0.85 # 15% additional haircut
details.extend([
f"Stage 1 PV: ${stage1_pv:,.0f}",
f"Stage 2 PV: ${stage2_pv:,.0f}",
f"Terminal PV: ${terminal_pv:,.0f}",
f"Total IV: ${intrinsic_value:,.0f}",
f"Conservative IV (15% haircut): ${conservative_intrinsic_value:,.0f}",
f"Owner earnings: ${owner_earnings:,.0f}",
f"Discount rate: {discount_rate:.1%}"
])
return {
"intrinsic_value": conservative_intrinsic_value,
"raw_intrinsic_value": intrinsic_value,
"owner_earnings": owner_earnings,
"assumptions": {
"stage1_growth": stage1_growth,
"stage2_growth": stage2_growth,
"terminal_growth": terminal_growth,
"discount_rate": discount_rate,
"stage1_years": stage1_years,
"stage2_years": stage2_years,
"historical_growth": conservative_growth if 'conservative_growth' in locals() else None,
},
"details": details,
}
def analyze_book_value_growth(financial_line_items: list) -> dict[str, any]:
if len(financial_line_items) < 3:
return {"score": 0, "details": "Insufficient data for book value analysis"}
# Extract book values per share
book_values = [
item.shareholders_equity / item.outstanding_shares
for item in financial_line_items
if hasattr(item, 'shareholders_equity') and hasattr(item, 'outstanding_shares')
and item.shareholders_equity and item.outstanding_shares
]
if len(book_values) < 3:
return {"score": 0, "details": "Insufficient book value data for growth analysis"}
score = 0
reasoning = []
# Analyze growth consistency
growth_periods = sum(1 for i in range(len(book_values) - 1) if book_values[i] > book_values[i + 1])
growth_rate = growth_periods / (len(book_values) - 1)
# Score based on consistency
if growth_rate >= 0.8:
score += 3
reasoning.append("Consistent book value per share growth (Buffett's favorite metric)")
elif growth_rate >= 0.6:
score += 2
reasoning.append("Good book value per share growth pattern")
elif growth_rate >= 0.4:
score += 1
reasoning.append("Moderate book value per share growth")
else:
reasoning.append("Inconsistent book value per share growth")
# Calculate and score CAGR
cagr_score, cagr_reason = _calculate_book_value_cagr(book_values)
score += cagr_score
reasoning.append(cagr_reason)
return {"score": score, "details": "; ".join(reasoning)}
def _calculate_book_value_cagr(book_values: list) -> tuple[int, str]:
if len(book_values) < 2:
return 0, "Insufficient data for CAGR calculation"
oldest_bv, latest_bv = book_values[-1], book_values[0]
years = len(book_values) - 1
# Handle different scenarios
if oldest_bv > 0 and latest_bv > 0:
cagr = ((latest_bv / oldest_bv) ** (1 / years)) - 1
if cagr > 0.15:
return 2, f"Excellent book value CAGR: {cagr:.1%}"
elif cagr > 0.1:
return 1, f"Good book value CAGR: {cagr:.1%}"
else:
return 0, f"Book value CAGR: {cagr:.1%}"
elif oldest_bv < 0 < latest_bv:
return 3, "Excellent: Company improved from negative to positive book value"
elif oldest_bv > 0 > latest_bv:
return 0, "Warning: Company declined from positive to negative book value"
else:
return 0, "Unable to calculate meaningful book value CAGR due to negative values"
def analyze_pricing_power(financial_line_items: list, metrics: list) -> dict[str, any]:
if not financial_line_items or not metrics:
return {"score": 0, "details": "Insufficient data for pricing power analysis"}
score = 0
reasoning = []
# Check gross margin trends (ability to maintain/expand margins)
gross_margins = []
for item in financial_line_items:
if hasattr(item, 'gross_margin') and item.gross_margin is not None:
gross_margins.append(item.gross_margin)
if len(gross_margins) >= 3:
# Check margin stability/improvement
recent_avg = sum(gross_margins[:2]) / 2 if len(gross_margins) >= 2 else gross_margins[0]
older_avg = sum(gross_margins[-2:]) / 2 if len(gross_margins) >= 2 else gross_margins[-1]
if recent_avg > older_avg + 0.02: # 2%+ improvement
score += 3
reasoning.append("Expanding gross margins indicate strong pricing power")
elif recent_avg > older_avg:
score += 2
reasoning.append("Improving gross margins suggest good pricing power")
elif abs(recent_avg - older_avg) < 0.01: # Stable within 1%
score += 1
reasoning.append("Stable gross margins during economic uncertainty")
else:
reasoning.append("Declining gross margins may indicate pricing pressure")
# Check if company has been able to maintain high margins consistently
if gross_margins:
avg_margin = sum(gross_margins) / len(gross_margins)
if avg_margin > 0.5: # 50%+ gross margins
score += 2
reasoning.append(f"Consistently high gross margins ({avg_margin:.1%}) indicate strong pricing power")
elif avg_margin > 0.3: # 30%+ gross margins
score += 1
reasoning.append(f"Good gross margins ({avg_margin:.1%}) suggest decent pricing power")
return {
"score": score,
"details": "; ".join(reasoning) if reasoning else "Limited pricing power analysis available"
}
def generate_buffett_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str = "warren_buffett_agent",
) -> WarrenBuffettSignal:
# --- Build compact facts here ---
facts = {
"score": analysis_data.get("score"),
"max_score": analysis_data.get("max_score"),
"fundamentals": analysis_data.get("fundamental_analysis", {}).get("details"),
"consistency": analysis_data.get("consistency_analysis", {}).get("details"),
"moat": analysis_data.get("moat_analysis", {}).get("details"),
"pricing_power": analysis_data.get("pricing_power_analysis", {}).get("details"),
"book_value": analysis_data.get("book_value_analysis", {}).get("details"),
"management": analysis_data.get("management_analysis", {}).get("details"),
"intrinsic_value": analysis_data.get("intrinsic_value_analysis", {}).get("intrinsic_value"),
"market_cap": analysis_data.get("market_cap"),
"margin_of_safety": analysis_data.get("margin_of_safety"),
}
template = ChatPromptTemplate.from_messages(
[
(
"system",
"You are Warren Buffett. Decide bullish, bearish, or neutral using only the provided facts.\n"
"\n"
"Checklist for decision:\n"
"- Circle of competence\n"
"- Competitive moat\n"
"- Management quality\n"
"- Financial strength\n"
"- Valuation vs intrinsic value\n"
"- Long-term prospects\n"
"\n"
"Signal rules:\n"
"- Bullish: strong business AND margin_of_safety > 0.\n"
"- Bearish: poor business OR clearly overvalued.\n"
"- Neutral: good business but margin_of_safety <= 0, or mixed evidence.\n"
"\n"
"Confidence scale:\n"
"- 90-100%: Exceptional business within my circle, trading at attractive price\n"
"- 70-89%: Good business with decent moat, fair valuation\n"
"- 50-69%: Mixed signals, would need more information or better price\n"
"- 30-49%: Outside my expertise or concerning fundamentals\n"
"- 10-29%: Poor business or significantly overvalued\n"
"\n"
"Keep reasoning under 120 characters. Do not invent data. Return JSON only."
),
(
"human",
"Ticker: {ticker}\n"
"Facts:\n{facts}\n\n"
"Return exactly:\n"
"{{\n"
' "signal": "bullish" | "bearish" | "neutral",\n'
' "confidence": int,\n'
' "reasoning": "short justification"\n'
"}}"
),
]
)
prompt = template.invoke({
"facts": json.dumps(facts, separators=(",", ":"), ensure_ascii=False),
"ticker": ticker,
})
# Default fallback uses int confidence to match schema and avoid parse retries
def create_default_warren_buffett_signal():
return WarrenBuffettSignal(signal="neutral", confidence=50, reasoning="Insufficient data")
return call_llm(
prompt=prompt,
pydantic_model=WarrenBuffettSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_warren_buffett_signal,
) | --- +++ @@ -17,6 +17,7 @@
def warren_buffett_agent(state: AgentState, agent_id: str = "warren_buffett_agent"):
+ """Analyzes stocks using Buffett's principles and LLM reasoning."""
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -153,6 +154,7 @@
def analyze_fundamentals(metrics: list) -> dict[str, any]:
+ """Analyze company fundamentals based on Buffett's criteria."""
if not metrics:
return {"score": 0, "details": "Insufficient fundamental data"}
@@ -201,6 +203,7 @@
def analyze_consistency(financial_line_items: list) -> dict[str, any]:
+ """Analyze earnings consistency and growth."""
if len(financial_line_items) < 4: # Need at least 4 periods for trend analysis
return {"score": 0, "details": "Insufficient historical data"}
@@ -233,6 +236,15 @@
def analyze_moat(metrics: list) -> dict[str, any]:
+ """
+ Evaluate whether the company likely has a durable competitive advantage (moat).
+ Enhanced to include multiple moat indicators that Buffett actually looks for:
+ 1. Consistent high returns on capital
+ 2. Pricing power (stable/growing margins)
+ 3. Scale advantages (improving metrics with size)
+ 4. Brand strength (inferred from margins and consistency)
+ 5. Switching costs (inferred from customer retention)
+ """
if not metrics or len(metrics) < 5: # Need more data for proper moat analysis
return {"score": 0, "max_score": 5, "details": "Insufficient data for comprehensive moat analysis"}
@@ -323,6 +335,13 @@
def analyze_management_quality(financial_line_items: list) -> dict[str, any]:
+ """
+ Checks for share dilution or consistent buybacks, and some dividend track record.
+ A simplified approach:
+ - if there's net share repurchase or stable share count, it suggests management
+ might be shareholder-friendly.
+ - if there's a big new issuance, it might be a negative sign (dilution).
+ """
if not financial_line_items:
return {"score": 0, "max_score": 2, "details": "Insufficient data for management analysis"}
@@ -359,6 +378,11 @@
def calculate_owner_earnings(financial_line_items: list) -> dict[str, any]:
+ """
+ Calculate owner earnings (Buffett's preferred measure of true earnings power).
+ Enhanced methodology: Net Income + Depreciation/Amortization - Maintenance CapEx - Working Capital Changes
+ Uses multi-period analysis for better maintenance capex estimation.
+ """
if not financial_line_items or len(financial_line_items) < 2:
return {"owner_earnings": None, "details": ["Insufficient data for owner earnings calculation"]}
@@ -430,6 +454,10 @@
def estimate_maintenance_capex(financial_line_items: list) -> float:
+ """
+ Estimate maintenance capital expenditure using multiple approaches.
+ Buffett considers this crucial for understanding true owner earnings.
+ """
if not financial_line_items:
return 0
@@ -478,6 +506,10 @@
def calculate_intrinsic_value(financial_line_items: list) -> dict[str, any]:
+ """
+ Calculate intrinsic value using enhanced DCF with owner earnings.
+ Uses more sophisticated assumptions and conservative approach like Buffett.
+ """
if not financial_line_items or len(financial_line_items) < 3:
return {"intrinsic_value": None, "details": ["Insufficient data for reliable valuation"]}
@@ -593,6 +625,7 @@
def analyze_book_value_growth(financial_line_items: list) -> dict[str, any]:
+ """Analyze book value per share growth - a key Buffett metric."""
if len(financial_line_items) < 3:
return {"score": 0, "details": "Insufficient data for book value analysis"}
@@ -636,6 +669,7 @@
def _calculate_book_value_cagr(book_values: list) -> tuple[int, str]:
+ """Helper function to safely calculate book value CAGR and return score + reasoning."""
if len(book_values) < 2:
return 0, "Insufficient data for CAGR calculation"
@@ -660,6 +694,10 @@
def analyze_pricing_power(financial_line_items: list, metrics: list) -> dict[str, any]:
+ """
+ Analyze pricing power - Buffett's key indicator of a business moat.
+ Looks at ability to raise prices without losing customers (margin expansion during inflation).
+ """
if not financial_line_items or not metrics:
return {"score": 0, "details": "Insufficient data for pricing power analysis"}
@@ -711,6 +749,7 @@ state: AgentState,
agent_id: str = "warren_buffett_agent",
) -> WarrenBuffettSignal:
+ """Get investment decision from LLM with a compact prompt."""
# --- Build compact facts here ---
facts = {
@@ -784,4 +823,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_warren_buffett_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/warren_buffett.py |
Create docstrings for API functions | from src.graph.state import AgentState, show_agent_reasoning
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from src.utils.llm import call_llm
from src.utils.progress import progress
from src.utils.api_key import get_api_key_from_state
class RakeshJhunjhunwalaSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def rakesh_jhunjhunwala_agent(state: AgentState, agent_id: str = "rakesh_jhunjhunwala_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
# Collect all analysis for LLM reasoning
analysis_data = {}
jhunjhunwala_analysis = {}
for ticker in tickers:
# Core Data
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="ttm", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching financial line items")
financial_line_items = search_line_items(
ticker,
[
"net_income",
"earnings_per_share",
"ebit",
"operating_income",
"revenue",
"operating_margin",
"total_assets",
"total_liabilities",
"current_assets",
"current_liabilities",
"free_cash_flow",
"dividends_and_other_cash_distributions",
"issuance_or_purchase_of_equity_shares"
],
end_date,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
# ─── Analyses ───────────────────────────────────────────────────────────
progress.update_status(agent_id, ticker, "Analyzing growth")
growth_analysis = analyze_growth(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing profitability")
profitability_analysis = analyze_profitability(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing balance sheet")
balancesheet_analysis = analyze_balance_sheet(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing cash flow")
cashflow_analysis = analyze_cash_flow(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing management actions")
management_analysis = analyze_management_actions(financial_line_items)
progress.update_status(agent_id, ticker, "Calculating intrinsic value")
# Calculate intrinsic value once
intrinsic_value = calculate_intrinsic_value(financial_line_items, market_cap)
# ─── Score & margin of safety ──────────────────────────────────────────
total_score = (
growth_analysis["score"]
+ profitability_analysis["score"]
+ balancesheet_analysis["score"]
+ cashflow_analysis["score"]
+ management_analysis["score"]
)
# Fixed: Correct max_score calculation based on actual scoring breakdown
max_score = 24 # 8(prof) + 7(growth) + 4(bs) + 3(cf) + 2(mgmt) = 24
# Calculate margin of safety
margin_of_safety = (
(intrinsic_value - market_cap) / market_cap if intrinsic_value and market_cap else None
)
# Jhunjhunwala's decision rules (30% minimum margin of safety for conviction)
if margin_of_safety is not None and margin_of_safety >= 0.30:
signal = "bullish"
elif margin_of_safety is not None and margin_of_safety <= -0.30:
signal = "bearish"
else:
# Use quality score as tie-breaker for neutral cases
quality_score = assess_quality_metrics(financial_line_items)
if quality_score >= 0.7 and total_score >= max_score * 0.6:
signal = "bullish" # High quality company at fair price
elif quality_score <= 0.4 or total_score <= max_score * 0.3:
signal = "bearish" # Poor quality or fundamentals
else:
signal = "neutral"
# Confidence based on margin of safety and quality
if margin_of_safety is not None:
confidence = min(max(abs(margin_of_safety) * 150, 20), 95) # 20-95% range
else:
confidence = min(max((total_score / max_score) * 100, 10), 80) # Based on score
# Create comprehensive analysis summary
intrinsic_value_analysis = analyze_rakesh_jhunjhunwala_style(
financial_line_items,
intrinsic_value=intrinsic_value,
current_price=market_cap
)
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_score,
"margin_of_safety": margin_of_safety,
"growth_analysis": growth_analysis,
"profitability_analysis": profitability_analysis,
"balancesheet_analysis": balancesheet_analysis,
"cashflow_analysis": cashflow_analysis,
"management_analysis": management_analysis,
"intrinsic_value_analysis": intrinsic_value_analysis,
"intrinsic_value": intrinsic_value,
"market_cap": market_cap,
}
# ─── LLM: craft Jhunjhunwala‑style narrative ──────────────────────────────
progress.update_status(agent_id, ticker, "Generating Jhunjhunwala analysis")
jhunjhunwala_output = generate_jhunjhunwala_output(
ticker=ticker,
analysis_data=analysis_data[ticker],
state=state,
agent_id=agent_id,
)
jhunjhunwala_analysis[ticker] = jhunjhunwala_output.model_dump()
progress.update_status(agent_id, ticker, "Done", analysis=jhunjhunwala_output.reasoning)
# ─── Push message back to graph state ──────────────────────────────────────
message = HumanMessage(content=json.dumps(jhunjhunwala_analysis), name=agent_id)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(jhunjhunwala_analysis, "Rakesh Jhunjhunwala Agent")
state["data"]["analyst_signals"][agent_id] = jhunjhunwala_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_profitability(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "details": "No profitability data available"}
latest = financial_line_items[0]
score = 0
reasoning = []
# Calculate ROE (Return on Equity) - Jhunjhunwala's key metric
if (getattr(latest, 'net_income', None) and latest.net_income > 0 and
getattr(latest, 'total_assets', None) and getattr(latest, 'total_liabilities', None) and
latest.total_assets and latest.total_liabilities):
shareholders_equity = latest.total_assets - latest.total_liabilities
if shareholders_equity > 0:
roe = (latest.net_income / shareholders_equity) * 100
if roe > 20: # Excellent ROE
score += 3
reasoning.append(f"Excellent ROE: {roe:.1f}%")
elif roe > 15: # Good ROE
score += 2
reasoning.append(f"Good ROE: {roe:.1f}%")
elif roe > 10: # Decent ROE
score += 1
reasoning.append(f"Decent ROE: {roe:.1f}%")
else:
reasoning.append(f"Low ROE: {roe:.1f}%")
else:
reasoning.append("Negative shareholders equity")
else:
reasoning.append("Unable to calculate ROE - missing data")
# Operating Margin Analysis
if (getattr(latest, "operating_income", None) and latest.operating_income and
getattr(latest, "revenue", None) and latest.revenue and latest.revenue > 0):
operating_margin = (latest.operating_income / latest.revenue) * 100
if operating_margin > 20: # Excellent margin
score += 2
reasoning.append(f"Excellent operating margin: {operating_margin:.1f}%")
elif operating_margin > 15: # Good margin
score += 1
reasoning.append(f"Good operating margin: {operating_margin:.1f}%")
elif operating_margin > 0:
reasoning.append(f"Positive operating margin: {operating_margin:.1f}%")
else:
reasoning.append(f"Negative operating margin: {operating_margin:.1f}%")
else:
reasoning.append("Unable to calculate operating margin")
# EPS Growth Consistency (3-year trend)
eps_values = [getattr(item, "earnings_per_share", None) for item in financial_line_items
if getattr(item, "earnings_per_share", None) is not None and getattr(item, "earnings_per_share", None) > 0]
if len(eps_values) >= 3:
# Calculate CAGR for EPS
initial_eps = eps_values[-1] # Oldest value
final_eps = eps_values[0] # Latest value
years = len(eps_values) - 1
if initial_eps > 0:
eps_cagr = ((final_eps / initial_eps) ** (1/years) - 1) * 100
if eps_cagr > 20: # High growth
score += 3
reasoning.append(f"High EPS CAGR: {eps_cagr:.1f}%")
elif eps_cagr > 15: # Good growth
score += 2
reasoning.append(f"Good EPS CAGR: {eps_cagr:.1f}%")
elif eps_cagr > 10: # Moderate growth
score += 1
reasoning.append(f"Moderate EPS CAGR: {eps_cagr:.1f}%")
else:
reasoning.append(f"Low EPS CAGR: {eps_cagr:.1f}%")
else:
reasoning.append("Cannot calculate EPS growth from negative base")
else:
reasoning.append("Insufficient EPS data for growth analysis")
return {"score": score, "details": "; ".join(reasoning)}
def analyze_growth(financial_line_items: list) -> dict[str, any]:
if len(financial_line_items) < 3:
return {"score": 0, "details": "Insufficient data for growth analysis"}
score = 0
reasoning = []
# Revenue CAGR Analysis
revenues = [getattr(item, "revenue", None) for item in financial_line_items
if getattr(item, "revenue", None) is not None and getattr(item, "revenue", None) > 0]
if len(revenues) >= 3:
initial_revenue = revenues[-1] # Oldest
final_revenue = revenues[0] # Latest
years = len(revenues) - 1
if initial_revenue > 0: # Fixed: Add zero check
revenue_cagr = ((final_revenue / initial_revenue) ** (1/years) - 1) * 100
if revenue_cagr > 20: # High growth
score += 3
reasoning.append(f"Excellent revenue CAGR: {revenue_cagr:.1f}%")
elif revenue_cagr > 15: # Good growth
score += 2
reasoning.append(f"Good revenue CAGR: {revenue_cagr:.1f}%")
elif revenue_cagr > 10: # Moderate growth
score += 1
reasoning.append(f"Moderate revenue CAGR: {revenue_cagr:.1f}%")
else:
reasoning.append(f"Low revenue CAGR: {revenue_cagr:.1f}%")
else:
reasoning.append("Cannot calculate revenue CAGR from zero base")
else:
reasoning.append("Insufficient revenue data for CAGR calculation")
# Net Income CAGR Analysis
net_incomes = [getattr(item, "net_income", None) for item in financial_line_items
if getattr(item, "net_income", None) is not None and getattr(item, "net_income", None) > 0]
if len(net_incomes) >= 3:
initial_income = net_incomes[-1] # Oldest
final_income = net_incomes[0] # Latest
years = len(net_incomes) - 1
if initial_income > 0: # Fixed: Add zero check
income_cagr = ((final_income / initial_income) ** (1/years) - 1) * 100
if income_cagr > 25: # Very high growth
score += 3
reasoning.append(f"Excellent income CAGR: {income_cagr:.1f}%")
elif income_cagr > 20: # High growth
score += 2
reasoning.append(f"High income CAGR: {income_cagr:.1f}%")
elif income_cagr > 15: # Good growth
score += 1
reasoning.append(f"Good income CAGR: {income_cagr:.1f}%")
else:
reasoning.append(f"Moderate income CAGR: {income_cagr:.1f}%")
else:
reasoning.append("Cannot calculate income CAGR from zero base")
else:
reasoning.append("Insufficient net income data for CAGR calculation")
# Revenue Consistency Check (year-over-year)
if len(revenues) >= 3:
declining_years = sum(1 for i in range(1, len(revenues)) if revenues[i-1] > revenues[i])
consistency_ratio = 1 - (declining_years / (len(revenues) - 1))
if consistency_ratio >= 0.8: # 80% or more years with growth
score += 1
reasoning.append(f"Consistent growth pattern ({consistency_ratio*100:.0f}% of years)")
else:
reasoning.append(f"Inconsistent growth pattern ({consistency_ratio*100:.0f}% of years)")
return {"score": score, "details": "; ".join(reasoning)}
def analyze_balance_sheet(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "details": "No balance sheet data"}
latest = financial_line_items[0]
score = 0
reasoning = []
# Debt to asset ratio
if (getattr(latest, "total_assets", None) and getattr(latest, "total_liabilities", None)
and latest.total_assets and latest.total_liabilities
and latest.total_assets > 0):
debt_ratio = latest.total_liabilities / latest.total_assets
if debt_ratio < 0.5:
score += 2
reasoning.append(f"Low debt ratio: {debt_ratio:.2f}")
elif debt_ratio < 0.7:
score += 1
reasoning.append(f"Moderate debt ratio: {debt_ratio:.2f}")
else:
reasoning.append(f"High debt ratio: {debt_ratio:.2f}")
else:
reasoning.append("Insufficient data to calculate debt ratio")
# Current ratio (liquidity)
if (getattr(latest, "current_assets", None) and getattr(latest, "current_liabilities", None)
and latest.current_assets and latest.current_liabilities
and latest.current_liabilities > 0):
current_ratio = latest.current_assets / latest.current_liabilities
if current_ratio > 2.0:
score += 2
reasoning.append(f"Excellent liquidity with current ratio: {current_ratio:.2f}")
elif current_ratio > 1.5:
score += 1
reasoning.append(f"Good liquidity with current ratio: {current_ratio:.2f}")
else:
reasoning.append(f"Weak liquidity with current ratio: {current_ratio:.2f}")
else:
reasoning.append("Insufficient data to calculate current ratio")
return {"score": score, "details": "; ".join(reasoning)}
def analyze_cash_flow(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "details": "No cash flow data"}
latest = financial_line_items[0]
score = 0
reasoning = []
# Free cash flow analysis
if getattr(latest, "free_cash_flow", None) and latest.free_cash_flow:
if latest.free_cash_flow > 0:
score += 2
reasoning.append(f"Positive free cash flow: {latest.free_cash_flow}")
else:
reasoning.append(f"Negative free cash flow: {latest.free_cash_flow}")
else:
reasoning.append("Free cash flow data not available")
# Dividend analysis
if getattr(latest, "dividends_and_other_cash_distributions", None) and latest.dividends_and_other_cash_distributions:
if latest.dividends_and_other_cash_distributions < 0: # Negative indicates cash outflow for dividends
score += 1
reasoning.append("Company pays dividends to shareholders")
else:
reasoning.append("No significant dividend payments")
else:
reasoning.append("No dividend payment data available")
return {"score": score, "details": "; ".join(reasoning)}
def analyze_management_actions(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "details": "No management action data"}
latest = financial_line_items[0]
score = 0
reasoning = []
issuance = getattr(latest, "issuance_or_purchase_of_equity_shares", None)
if issuance is not None:
if issuance < 0: # Negative indicates share buybacks
score += 2
reasoning.append(f"Company buying back shares: {abs(issuance)}")
elif issuance > 0:
reasoning.append(f"Share issuance detected (potential dilution): {issuance}")
else:
score += 1
reasoning.append("No recent share issuance or buyback")
else:
reasoning.append("No data on share issuance or buybacks")
return {"score": score, "details": "; ".join(reasoning)}
def assess_quality_metrics(financial_line_items: list) -> float:
if not financial_line_items:
return 0.5 # Neutral score
latest = financial_line_items[0]
quality_factors = []
# ROE consistency and level
if (getattr(latest, 'net_income', None) and getattr(latest, 'total_assets', None) and
getattr(latest, 'total_liabilities', None) and latest.total_assets and latest.total_liabilities):
shareholders_equity = latest.total_assets - latest.total_liabilities
if shareholders_equity > 0 and latest.net_income:
roe = latest.net_income / shareholders_equity
if roe > 0.20: # ROE > 20%
quality_factors.append(1.0)
elif roe > 0.15: # ROE > 15%
quality_factors.append(0.8)
elif roe > 0.10: # ROE > 10%
quality_factors.append(0.6)
else:
quality_factors.append(0.3)
else:
quality_factors.append(0.0)
else:
quality_factors.append(0.5)
# Debt levels (lower is better)
if (getattr(latest, 'total_assets', None) and getattr(latest, 'total_liabilities', None) and
latest.total_assets and latest.total_liabilities):
debt_ratio = latest.total_liabilities / latest.total_assets
if debt_ratio < 0.3: # Low debt
quality_factors.append(1.0)
elif debt_ratio < 0.5: # Moderate debt
quality_factors.append(0.7)
elif debt_ratio < 0.7: # High debt
quality_factors.append(0.4)
else: # Very high debt
quality_factors.append(0.1)
else:
quality_factors.append(0.5)
# Growth consistency
net_incomes = [getattr(item, "net_income", None) for item in financial_line_items[:4]
if getattr(item, "net_income", None) is not None and getattr(item, "net_income", None) > 0]
if len(net_incomes) >= 3:
declining_years = sum(1 for i in range(1, len(net_incomes)) if net_incomes[i-1] > net_incomes[i])
consistency = 1 - (declining_years / (len(net_incomes) - 1))
quality_factors.append(consistency)
else:
quality_factors.append(0.5)
# Return average quality score
return sum(quality_factors) / len(quality_factors) if quality_factors else 0.5
def calculate_intrinsic_value(financial_line_items: list, market_cap: float) -> float:
if not financial_line_items or not market_cap:
return None
try:
latest = financial_line_items[0]
# Need positive earnings as base
if not getattr(latest, 'net_income', None) or latest.net_income <= 0:
return None
# Get historical earnings for growth calculation
net_incomes = [getattr(item, "net_income", None) for item in financial_line_items[:5]
if getattr(item, "net_income", None) is not None and getattr(item, "net_income", None) > 0]
if len(net_incomes) < 2:
# Use current earnings with conservative multiple for stable companies
return latest.net_income * 12 # Conservative P/E of 12
# Calculate sustainable growth rate using historical data
initial_income = net_incomes[-1] # Oldest
final_income = net_incomes[0] # Latest
years = len(net_incomes) - 1
# Calculate historical CAGR
if initial_income > 0: # Fixed: Add zero check
historical_growth = ((final_income / initial_income) ** (1/years) - 1)
else:
historical_growth = 0.05 # Default to 5%
# Conservative growth assumptions (Jhunjhunwala style)
if historical_growth > 0.25: # Cap at 25% for sustainability
sustainable_growth = 0.20 # Conservative 20%
elif historical_growth > 0.15:
sustainable_growth = historical_growth * 0.8 # 80% of historical
elif historical_growth > 0.05:
sustainable_growth = historical_growth * 0.9 # 90% of historical
else:
sustainable_growth = 0.05 # Minimum 5% for inflation
# Quality assessment affects discount rate
quality_score = assess_quality_metrics(financial_line_items)
# Discount rate based on quality (Jhunjhunwala preferred quality)
if quality_score >= 0.8: # High quality
discount_rate = 0.12 # 12% for high quality companies
terminal_multiple = 18
elif quality_score >= 0.6: # Medium quality
discount_rate = 0.15 # 15% for medium quality
terminal_multiple = 15
else: # Lower quality
discount_rate = 0.18 # 18% for riskier companies
terminal_multiple = 12
# Simple DCF with terminal value
current_earnings = latest.net_income
terminal_value = 0
dcf_value = 0
# Project 5 years of earnings
for year in range(1, 6):
projected_earnings = current_earnings * ((1 + sustainable_growth) ** year)
present_value = projected_earnings / ((1 + discount_rate) ** year)
dcf_value += present_value
# Terminal value (year 5 earnings * terminal multiple)
year_5_earnings = current_earnings * ((1 + sustainable_growth) ** 5)
terminal_value = (year_5_earnings * terminal_multiple) / ((1 + discount_rate) ** 5)
total_intrinsic_value = dcf_value + terminal_value
return total_intrinsic_value
except Exception:
# Fallback to simple earnings multiple
if getattr(latest, 'net_income', None) and latest.net_income > 0:
return latest.net_income * 15
return None
def analyze_rakesh_jhunjhunwala_style(
financial_line_items: list,
owner_earnings: float = None,
intrinsic_value: float = None,
current_price: float = None,
) -> dict[str, any]:
# Run sub-analyses
profitability = analyze_profitability(financial_line_items)
growth = analyze_growth(financial_line_items)
balance_sheet = analyze_balance_sheet(financial_line_items)
cash_flow = analyze_cash_flow(financial_line_items)
management = analyze_management_actions(financial_line_items)
total_score = (
profitability["score"]
+ growth["score"]
+ balance_sheet["score"]
+ cash_flow["score"]
+ management["score"]
)
details = (
f"Profitability: {profitability['details']}\n"
f"Growth: {growth['details']}\n"
f"Balance Sheet: {balance_sheet['details']}\n"
f"Cash Flow: {cash_flow['details']}\n"
f"Management Actions: {management['details']}"
)
# Use provided intrinsic value or calculate if not provided
if not intrinsic_value:
intrinsic_value = calculate_intrinsic_value(financial_line_items, current_price)
valuation_gap = None
if intrinsic_value and current_price:
valuation_gap = intrinsic_value - current_price
return {
"total_score": total_score,
"details": details,
"owner_earnings": owner_earnings,
"intrinsic_value": intrinsic_value,
"current_price": current_price,
"valuation_gap": valuation_gap,
"breakdown": {
"profitability": profitability,
"growth": growth,
"balance_sheet": balance_sheet,
"cash_flow": cash_flow,
"management": management,
},
}
# ────────────────────────────────────────────────────────────────────────────────
# LLM generation
# ────────────────────────────────────────────────────────────────────────────────
def generate_jhunjhunwala_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> RakeshJhunjhunwalaSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Rakesh Jhunjhunwala AI agent. Decide on investment signals based on Rakesh Jhunjhunwala's principles:
- Circle of Competence: Only invest in businesses you understand
- Margin of Safety (> 30%): Buy at a significant discount to intrinsic value
- Economic Moat: Look for durable competitive advantages
- Quality Management: Seek conservative, shareholder-oriented teams
- Financial Strength: Favor low debt, strong returns on equity
- Long-term Horizon: Invest in businesses, not just stocks
- Growth Focus: Look for companies with consistent earnings and revenue growth
- Sell only if fundamentals deteriorate or valuation far exceeds intrinsic value
When providing your reasoning, be thorough and specific by:
1. Explaining the key factors that influenced your decision the most (both positive and negative)
2. Highlighting how the company aligns with or violates specific Jhunjhunwala principles
3. Providing quantitative evidence where relevant (e.g., specific margins, ROE values, debt levels)
4. Concluding with a Jhunjhunwala-style assessment of the investment opportunity
5. Using Rakesh Jhunjhunwala's voice and conversational style in your explanation
For example, if bullish: "I'm particularly impressed with the consistent growth and strong balance sheet, reminiscent of quality companies that create long-term wealth..."
For example, if bearish: "The deteriorating margins and high debt levels concern me - this doesn't fit the profile of companies that build lasting value..."
Follow these guidelines strictly.
""",
),
(
"human",
"""Based on the following data, create the investment signal as Rakesh Jhunjhunwala would:
Analysis Data for {ticker}:
{analysis_data}
Return the trading signal in the following JSON format exactly:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": float between 0 and 100,
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
# Default fallback signal in case parsing fails
def create_default_rakesh_jhunjhunwala_signal():
return RakeshJhunjhunwalaSignal(signal="neutral", confidence=0.0, reasoning="Error in analysis, defaulting to neutral")
return call_llm(
prompt=prompt,
pydantic_model=RakeshJhunjhunwalaSignal,
state=state,
agent_name=agent_id,
default_factory=create_default_rakesh_jhunjhunwala_signal,
) | --- +++ @@ -15,6 +15,7 @@ reasoning: str
def rakesh_jhunjhunwala_agent(state: AgentState, agent_id: str = "rakesh_jhunjhunwala_agent"):
+ """Analyzes stocks using Rakesh Jhunjhunwala's principles and LLM reasoning."""
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -159,6 +160,10 @@
def analyze_profitability(financial_line_items: list) -> dict[str, any]:
+ """
+ Analyze profitability metrics like net income, EBIT, EPS, operating income.
+ Focus on strong, consistent earnings growth and operating efficiency.
+ """
if not financial_line_items:
return {"score": 0, "details": "No profitability data available"}
@@ -239,6 +244,10 @@
def analyze_growth(financial_line_items: list) -> dict[str, any]:
+ """
+ Analyze revenue and net income growth trends using CAGR.
+ Jhunjhunwala favored companies with strong, consistent compound growth.
+ """
if len(financial_line_items) < 3:
return {"score": 0, "details": "Insufficient data for growth analysis"}
@@ -316,6 +325,10 @@
def analyze_balance_sheet(financial_line_items: list) -> dict[str, any]:
+ """
+ Check financial strength - healthy asset/liability structure, liquidity.
+ Jhunjhunwala favored companies with clean balance sheets and manageable debt.
+ """
if not financial_line_items:
return {"score": 0, "details": "No balance sheet data"}
@@ -359,6 +372,10 @@
def analyze_cash_flow(financial_line_items: list) -> dict[str, any]:
+ """
+ Evaluate free cash flow and dividend behavior.
+ Jhunjhunwala appreciated companies generating strong free cash flow and rewarding shareholders.
+ """
if not financial_line_items:
return {"score": 0, "details": "No cash flow data"}
@@ -390,6 +407,10 @@
def analyze_management_actions(financial_line_items: list) -> dict[str, any]:
+ """
+ Look at share issuance or buybacks to assess shareholder friendliness.
+ Jhunjhunwala liked managements who buy back shares or avoid dilution.
+ """
if not financial_line_items:
return {"score": 0, "details": "No management action data"}
@@ -414,6 +435,10 @@
def assess_quality_metrics(financial_line_items: list) -> float:
+ """
+ Assess company quality based on Jhunjhunwala's criteria.
+ Returns a score between 0 and 1.
+ """
if not financial_line_items:
return 0.5 # Neutral score
@@ -471,6 +496,12 @@
def calculate_intrinsic_value(financial_line_items: list, market_cap: float) -> float:
+ """
+ Calculate intrinsic value using Rakesh Jhunjhunwala's approach:
+ - Focus on earnings power and growth
+ - Conservative discount rates
+ - Quality premium for consistent performers
+ """
if not financial_line_items or not market_cap:
return None
@@ -556,6 +587,9 @@ intrinsic_value: float = None,
current_price: float = None,
) -> dict[str, any]:
+ """
+ Comprehensive analysis in Rakesh Jhunjhunwala's investment style.
+ """
# Run sub-analyses
profitability = analyze_profitability(financial_line_items)
growth = analyze_growth(financial_line_items)
@@ -613,6 +647,7 @@ state: AgentState,
agent_id: str,
) -> RakeshJhunjhunwalaSignal:
+ """Get investment decision from LLM with Jhunjhunwala's principles"""
template = ChatPromptTemplate.from_messages(
[
(
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/rakesh_jhunjhunwala.py |
Add clean documentation to messy code |
from src.agents import portfolio_manager
from src.agents.aswath_damodaran import aswath_damodaran_agent
from src.agents.ben_graham import ben_graham_agent
from src.agents.bill_ackman import bill_ackman_agent
from src.agents.cathie_wood import cathie_wood_agent
from src.agents.charlie_munger import charlie_munger_agent
from src.agents.fundamentals import fundamentals_analyst_agent
from src.agents.michael_burry import michael_burry_agent
from src.agents.phil_fisher import phil_fisher_agent
from src.agents.peter_lynch import peter_lynch_agent
from src.agents.sentiment import sentiment_analyst_agent
from src.agents.stanley_druckenmiller import stanley_druckenmiller_agent
from src.agents.technicals import technical_analyst_agent
from src.agents.valuation import valuation_analyst_agent
from src.agents.warren_buffett import warren_buffett_agent
from src.agents.rakesh_jhunjhunwala import rakesh_jhunjhunwala_agent
from src.agents.mohnish_pabrai import mohnish_pabrai_agent
from src.agents.news_sentiment import news_sentiment_agent
from src.agents.growth_agent import growth_analyst_agent
# Define analyst configuration - single source of truth
ANALYST_CONFIG = {
"aswath_damodaran": {
"display_name": "Aswath Damodaran",
"description": "The Dean of Valuation",
"investing_style": "Focuses on intrinsic value and financial metrics to assess investment opportunities through rigorous valuation analysis.",
"agent_func": aswath_damodaran_agent,
"type": "analyst",
"order": 0,
},
"ben_graham": {
"display_name": "Ben Graham",
"description": "The Father of Value Investing",
"investing_style": "Emphasizes a margin of safety and invests in undervalued companies with strong fundamentals through systematic value analysis.",
"agent_func": ben_graham_agent,
"type": "analyst",
"order": 1,
},
"bill_ackman": {
"display_name": "Bill Ackman",
"description": "The Activist Investor",
"investing_style": "Seeks to influence management and unlock value through strategic activism and contrarian investment positions.",
"agent_func": bill_ackman_agent,
"type": "analyst",
"order": 2,
},
"cathie_wood": {
"display_name": "Cathie Wood",
"description": "The Queen of Growth Investing",
"investing_style": "Focuses on disruptive innovation and growth, investing in companies that are leading technological advancements and market disruption.",
"agent_func": cathie_wood_agent,
"type": "analyst",
"order": 3,
},
"charlie_munger": {
"display_name": "Charlie Munger",
"description": "The Rational Thinker",
"investing_style": "Advocates for value investing with a focus on quality businesses and long-term growth through rational decision-making.",
"agent_func": charlie_munger_agent,
"type": "analyst",
"order": 4,
},
"michael_burry": {
"display_name": "Michael Burry",
"description": "The Big Short Contrarian",
"investing_style": "Makes contrarian bets, often shorting overvalued markets and investing in undervalued assets through deep fundamental analysis.",
"agent_func": michael_burry_agent,
"type": "analyst",
"order": 5,
},
"mohnish_pabrai": {
"display_name": "Mohnish Pabrai",
"description": "The Dhandho Investor",
"investing_style": "Focuses on value investing and long-term growth through fundamental analysis and a margin of safety.",
"agent_func": mohnish_pabrai_agent,
"type": "analyst",
"order": 6,
},
"peter_lynch": {
"display_name": "Peter Lynch",
"description": "The 10-Bagger Investor",
"investing_style": "Invests in companies with understandable business models and strong growth potential using the 'buy what you know' strategy.",
"agent_func": peter_lynch_agent,
"type": "analyst",
"order": 6,
},
"phil_fisher": {
"display_name": "Phil Fisher",
"description": "The Scuttlebutt Investor",
"investing_style": "Emphasizes investing in companies with strong management and innovative products, focusing on long-term growth through scuttlebutt research.",
"agent_func": phil_fisher_agent,
"type": "analyst",
"order": 7,
},
"rakesh_jhunjhunwala": {
"display_name": "Rakesh Jhunjhunwala",
"description": "The Big Bull Of India",
"investing_style": "Leverages macroeconomic insights to invest in high-growth sectors, particularly within emerging markets and domestic opportunities.",
"agent_func": rakesh_jhunjhunwala_agent,
"type": "analyst",
"order": 8,
},
"stanley_druckenmiller": {
"display_name": "Stanley Druckenmiller",
"description": "The Macro Investor",
"investing_style": "Focuses on macroeconomic trends, making large bets on currencies, commodities, and interest rates through top-down analysis.",
"agent_func": stanley_druckenmiller_agent,
"type": "analyst",
"order": 9,
},
"warren_buffett": {
"display_name": "Warren Buffett",
"description": "The Oracle of Omaha",
"investing_style": "Seeks companies with strong fundamentals and competitive advantages through value investing and long-term ownership.",
"agent_func": warren_buffett_agent,
"type": "analyst",
"order": 10,
},
"technical_analyst": {
"display_name": "Technical Analyst",
"description": "Chart Pattern Specialist",
"investing_style": "Focuses on chart patterns and market trends to make investment decisions, often using technical indicators and price action analysis.",
"agent_func": technical_analyst_agent,
"type": "analyst",
"order": 11,
},
"fundamentals_analyst": {
"display_name": "Fundamentals Analyst",
"description": "Financial Statement Specialist",
"investing_style": "Delves into financial statements and economic indicators to assess the intrinsic value of companies through fundamental analysis.",
"agent_func": fundamentals_analyst_agent,
"type": "analyst",
"order": 12,
},
"growth_analyst": {
"display_name": "Growth Analyst",
"description": "Growth Specialist",
"investing_style": "Analyzes growth trends and valuation to identify growth opportunities through growth analysis.",
"agent_func": growth_analyst_agent,
"type": "analyst",
"order": 13,
},
"news_sentiment_analyst": {
"display_name": "News Sentiment Analyst",
"description": "News Sentiment Specialist",
"investing_style": "Analyzes news sentiment to predict market movements and identify opportunities through news analysis.",
"agent_func": news_sentiment_agent,
"type": "analyst",
"order": 14,
},
"sentiment_analyst": {
"display_name": "Sentiment Analyst",
"description": "Market Sentiment Specialist",
"investing_style": "Gauges market sentiment and investor behavior to predict market movements and identify opportunities through behavioral analysis.",
"agent_func": sentiment_analyst_agent,
"type": "analyst",
"order": 15,
},
"valuation_analyst": {
"display_name": "Valuation Analyst",
"description": "Company Valuation Specialist",
"investing_style": "Specializes in determining the fair value of companies, using various valuation models and financial metrics for investment decisions.",
"agent_func": valuation_analyst_agent,
"type": "analyst",
"order": 16,
},
}
# Derive ANALYST_ORDER from ANALYST_CONFIG for backwards compatibility
ANALYST_ORDER = [(config["display_name"], key) for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])]
def get_analyst_nodes():
return {key: (f"{key}_agent", config["agent_func"]) for key, config in ANALYST_CONFIG.items()}
def get_agents_list():
return [
{
"key": key,
"display_name": config["display_name"],
"description": config["description"],
"investing_style": config["investing_style"],
"order": config["order"]
}
for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])
] | --- +++ @@ -1,3 +1,4 @@+"""Constants and utilities related to analysts configuration."""
from src.agents import portfolio_manager
from src.agents.aswath_damodaran import aswath_damodaran_agent
@@ -172,10 +173,12 @@
def get_analyst_nodes():
+ """Get the mapping of analyst keys to their (node_name, agent_func) tuples."""
return {key: (f"{key}_agent", config["agent_func"]) for key, config in ANALYST_CONFIG.items()}
def get_agents_list():
+ """Get the list of agents for API responses."""
return [
{
"key": key,
@@ -185,4 +188,4 @@ "order": config["order"]
}
for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])
- ]+ ]
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/utils/analysts.py |
Document all public functions with docstrings | from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.orm import Session
from typing import List
from app.backend.database import get_db
from app.backend.repositories.api_key_repository import ApiKeyRepository
from app.backend.models.schemas import (
ApiKeyCreateRequest,
ApiKeyUpdateRequest,
ApiKeyResponse,
ApiKeySummaryResponse,
ApiKeyBulkUpdateRequest,
ErrorResponse
)
router = APIRouter(prefix="/api-keys", tags=["api-keys"])
@router.post(
"/",
response_model=ApiKeyResponse,
responses={
400: {"model": ErrorResponse, "description": "Invalid request"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def create_or_update_api_key(request: ApiKeyCreateRequest, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
api_key = repo.create_or_update_api_key(
provider=request.provider,
key_value=request.key_value,
description=request.description,
is_active=request.is_active
)
return ApiKeyResponse.from_orm(api_key)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to create/update API key: {str(e)}")
@router.get(
"/",
response_model=List[ApiKeySummaryResponse],
responses={
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_api_keys(include_inactive: bool = False, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
api_keys = repo.get_all_api_keys(include_inactive=include_inactive)
return [ApiKeySummaryResponse.from_orm(key) for key in api_keys]
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve API keys: {str(e)}")
@router.get(
"/{provider}",
response_model=ApiKeyResponse,
responses={
404: {"model": ErrorResponse, "description": "API key not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def get_api_key(provider: str, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
api_key = repo.get_api_key_by_provider(provider)
if not api_key:
raise HTTPException(status_code=404, detail="API key not found")
return ApiKeyResponse.from_orm(api_key)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to retrieve API key: {str(e)}")
@router.put(
"/{provider}",
response_model=ApiKeyResponse,
responses={
404: {"model": ErrorResponse, "description": "API key not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def update_api_key(provider: str, request: ApiKeyUpdateRequest, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
api_key = repo.update_api_key(
provider=provider,
key_value=request.key_value,
description=request.description,
is_active=request.is_active
)
if not api_key:
raise HTTPException(status_code=404, detail="API key not found")
return ApiKeyResponse.from_orm(api_key)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to update API key: {str(e)}")
@router.delete(
"/{provider}",
responses={
204: {"description": "API key deleted successfully"},
404: {"model": ErrorResponse, "description": "API key not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def delete_api_key(provider: str, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
success = repo.delete_api_key(provider)
if not success:
raise HTTPException(status_code=404, detail="API key not found")
return {"message": "API key deleted successfully"}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to delete API key: {str(e)}")
@router.patch(
"/{provider}/deactivate",
response_model=ApiKeySummaryResponse,
responses={
404: {"model": ErrorResponse, "description": "API key not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def deactivate_api_key(provider: str, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
success = repo.deactivate_api_key(provider)
if not success:
raise HTTPException(status_code=404, detail="API key not found")
# Return the updated key
api_key = repo.get_api_key_by_provider(provider)
return ApiKeySummaryResponse.from_orm(api_key)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to deactivate API key: {str(e)}")
@router.post(
"/bulk",
response_model=List[ApiKeyResponse],
responses={
400: {"model": ErrorResponse, "description": "Invalid request"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def bulk_update_api_keys(request: ApiKeyBulkUpdateRequest, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
api_keys_data = [
{
'provider': key.provider,
'key_value': key.key_value,
'description': key.description,
'is_active': key.is_active
}
for key in request.api_keys
]
api_keys = repo.bulk_create_or_update(api_keys_data)
return [ApiKeyResponse.from_orm(key) for key in api_keys]
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to bulk update API keys: {str(e)}")
@router.patch(
"/{provider}/last-used",
responses={
200: {"description": "Last used timestamp updated"},
404: {"model": ErrorResponse, "description": "API key not found"},
500: {"model": ErrorResponse, "description": "Internal server error"},
},
)
async def update_last_used(provider: str, db: Session = Depends(get_db)):
try:
repo = ApiKeyRepository(db)
success = repo.update_last_used(provider)
if not success:
raise HTTPException(status_code=404, detail="API key not found")
return {"message": "Last used timestamp updated"}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to update last used timestamp: {str(e)}") | --- +++ @@ -25,6 +25,7 @@ },
)
async def create_or_update_api_key(request: ApiKeyCreateRequest, db: Session = Depends(get_db)):
+ """Create a new API key or update existing one"""
try:
repo = ApiKeyRepository(db)
api_key = repo.create_or_update_api_key(
@@ -46,6 +47,7 @@ },
)
async def get_api_keys(include_inactive: bool = False, db: Session = Depends(get_db)):
+ """Get all API keys (without actual key values for security)"""
try:
repo = ApiKeyRepository(db)
api_keys = repo.get_all_api_keys(include_inactive=include_inactive)
@@ -63,6 +65,7 @@ },
)
async def get_api_key(provider: str, db: Session = Depends(get_db)):
+ """Get a specific API key by provider"""
try:
repo = ApiKeyRepository(db)
api_key = repo.get_api_key_by_provider(provider)
@@ -84,6 +87,7 @@ },
)
async def update_api_key(provider: str, request: ApiKeyUpdateRequest, db: Session = Depends(get_db)):
+ """Update an existing API key"""
try:
repo = ApiKeyRepository(db)
api_key = repo.update_api_key(
@@ -110,6 +114,7 @@ },
)
async def delete_api_key(provider: str, db: Session = Depends(get_db)):
+ """Delete an API key"""
try:
repo = ApiKeyRepository(db)
success = repo.delete_api_key(provider)
@@ -131,6 +136,7 @@ },
)
async def deactivate_api_key(provider: str, db: Session = Depends(get_db)):
+ """Deactivate an API key without deleting it"""
try:
repo = ApiKeyRepository(db)
success = repo.deactivate_api_key(provider)
@@ -155,6 +161,7 @@ },
)
async def bulk_update_api_keys(request: ApiKeyBulkUpdateRequest, db: Session = Depends(get_db)):
+ """Bulk create or update multiple API keys"""
try:
repo = ApiKeyRepository(db)
api_keys_data = [
@@ -181,6 +188,7 @@ },
)
async def update_last_used(provider: str, db: Session = Depends(get_db)):
+ """Update the last used timestamp for an API key"""
try:
repo = ApiKeyRepository(db)
success = repo.update_last_used(provider)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/app/backend/routes/api_keys.py |
Write docstrings describing each step | import math
from langchain_core.messages import HumanMessage
from src.graph.state import AgentState, show_agent_reasoning
from src.utils.api_key import get_api_key_from_state
import json
import pandas as pd
import numpy as np
from src.tools.api import get_prices, prices_to_df
from src.utils.progress import progress
def safe_float(value, default=0.0):
try:
if pd.isna(value) or np.isnan(value):
return default
return float(value)
except (ValueError, TypeError, OverflowError):
return default
##### Technical Analyst #####
def technical_analyst_agent(state: AgentState, agent_id: str = "technical_analyst_agent"):
data = state["data"]
start_date = data["start_date"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
# Initialize analysis for each ticker
technical_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Analyzing price data")
# Get the historical price data
prices = get_prices(
ticker=ticker,
start_date=start_date,
end_date=end_date,
api_key=api_key,
)
if not prices:
progress.update_status(agent_id, ticker, "Failed: No price data found")
continue
# Convert prices to a DataFrame
prices_df = prices_to_df(prices)
progress.update_status(agent_id, ticker, "Calculating trend signals")
trend_signals = calculate_trend_signals(prices_df)
progress.update_status(agent_id, ticker, "Calculating mean reversion")
mean_reversion_signals = calculate_mean_reversion_signals(prices_df)
progress.update_status(agent_id, ticker, "Calculating momentum")
momentum_signals = calculate_momentum_signals(prices_df)
progress.update_status(agent_id, ticker, "Analyzing volatility")
volatility_signals = calculate_volatility_signals(prices_df)
progress.update_status(agent_id, ticker, "Statistical analysis")
stat_arb_signals = calculate_stat_arb_signals(prices_df)
# Combine all signals using a weighted ensemble approach
strategy_weights = {
"trend": 0.25,
"mean_reversion": 0.20,
"momentum": 0.25,
"volatility": 0.15,
"stat_arb": 0.15,
}
progress.update_status(agent_id, ticker, "Combining signals")
combined_signal = weighted_signal_combination(
{
"trend": trend_signals,
"mean_reversion": mean_reversion_signals,
"momentum": momentum_signals,
"volatility": volatility_signals,
"stat_arb": stat_arb_signals,
},
strategy_weights,
)
# Generate detailed analysis report for this ticker
technical_analysis[ticker] = {
"signal": combined_signal["signal"],
"confidence": round(combined_signal["confidence"] * 100),
"reasoning": {
"trend_following": {
"signal": trend_signals["signal"],
"confidence": round(trend_signals["confidence"] * 100),
"metrics": normalize_pandas(trend_signals["metrics"]),
},
"mean_reversion": {
"signal": mean_reversion_signals["signal"],
"confidence": round(mean_reversion_signals["confidence"] * 100),
"metrics": normalize_pandas(mean_reversion_signals["metrics"]),
},
"momentum": {
"signal": momentum_signals["signal"],
"confidence": round(momentum_signals["confidence"] * 100),
"metrics": normalize_pandas(momentum_signals["metrics"]),
},
"volatility": {
"signal": volatility_signals["signal"],
"confidence": round(volatility_signals["confidence"] * 100),
"metrics": normalize_pandas(volatility_signals["metrics"]),
},
"statistical_arbitrage": {
"signal": stat_arb_signals["signal"],
"confidence": round(stat_arb_signals["confidence"] * 100),
"metrics": normalize_pandas(stat_arb_signals["metrics"]),
},
},
}
progress.update_status(agent_id, ticker, "Done", analysis=json.dumps(technical_analysis, indent=4))
# Create the technical analyst message
message = HumanMessage(
content=json.dumps(technical_analysis),
name=agent_id,
)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(technical_analysis, "Technical Analyst")
# Add the signal to the analyst_signals list
state["data"]["analyst_signals"][agent_id] = technical_analysis
progress.update_status(agent_id, None, "Done")
return {
"messages": state["messages"] + [message],
"data": data,
}
def calculate_trend_signals(prices_df):
# Calculate EMAs for multiple timeframes
ema_8 = calculate_ema(prices_df, 8)
ema_21 = calculate_ema(prices_df, 21)
ema_55 = calculate_ema(prices_df, 55)
# Calculate ADX for trend strength
adx = calculate_adx(prices_df, 14)
# Determine trend direction and strength
short_trend = ema_8 > ema_21
medium_trend = ema_21 > ema_55
# Combine signals with confidence weighting
trend_strength = adx["adx"].iloc[-1] / 100.0
if short_trend.iloc[-1] and medium_trend.iloc[-1]:
signal = "bullish"
confidence = trend_strength
elif not short_trend.iloc[-1] and not medium_trend.iloc[-1]:
signal = "bearish"
confidence = trend_strength
else:
signal = "neutral"
confidence = 0.5
return {
"signal": signal,
"confidence": confidence,
"metrics": {
"adx": safe_float(adx["adx"].iloc[-1]),
"trend_strength": safe_float(trend_strength),
},
}
def calculate_mean_reversion_signals(prices_df):
# Calculate z-score of price relative to moving average
ma_50 = prices_df["close"].rolling(window=50).mean()
std_50 = prices_df["close"].rolling(window=50).std()
z_score = (prices_df["close"] - ma_50) / std_50
# Calculate Bollinger Bands
bb_upper, bb_lower = calculate_bollinger_bands(prices_df)
# Calculate RSI with multiple timeframes
rsi_14 = calculate_rsi(prices_df, 14)
rsi_28 = calculate_rsi(prices_df, 28)
# Mean reversion signals
price_vs_bb = (prices_df["close"].iloc[-1] - bb_lower.iloc[-1]) / (bb_upper.iloc[-1] - bb_lower.iloc[-1])
# Combine signals
if z_score.iloc[-1] < -2 and price_vs_bb < 0.2:
signal = "bullish"
confidence = min(abs(z_score.iloc[-1]) / 4, 1.0)
elif z_score.iloc[-1] > 2 and price_vs_bb > 0.8:
signal = "bearish"
confidence = min(abs(z_score.iloc[-1]) / 4, 1.0)
else:
signal = "neutral"
confidence = 0.5
return {
"signal": signal,
"confidence": confidence,
"metrics": {
"z_score": safe_float(z_score.iloc[-1]),
"price_vs_bb": safe_float(price_vs_bb),
"rsi_14": safe_float(rsi_14.iloc[-1]),
"rsi_28": safe_float(rsi_28.iloc[-1]),
},
}
def calculate_momentum_signals(prices_df):
# Price momentum
returns = prices_df["close"].pct_change()
mom_1m = returns.rolling(21).sum()
mom_3m = returns.rolling(63).sum()
mom_6m = returns.rolling(126).sum()
# Volume momentum
volume_ma = prices_df["volume"].rolling(21).mean()
volume_momentum = prices_df["volume"] / volume_ma
# Relative strength
# (would compare to market/sector in real implementation)
# Calculate momentum score
momentum_score = (0.4 * mom_1m + 0.3 * mom_3m + 0.3 * mom_6m).iloc[-1]
# Volume confirmation
volume_confirmation = volume_momentum.iloc[-1] > 1.0
if momentum_score > 0.05 and volume_confirmation:
signal = "bullish"
confidence = min(abs(momentum_score) * 5, 1.0)
elif momentum_score < -0.05 and volume_confirmation:
signal = "bearish"
confidence = min(abs(momentum_score) * 5, 1.0)
else:
signal = "neutral"
confidence = 0.5
return {
"signal": signal,
"confidence": confidence,
"metrics": {
"momentum_1m": safe_float(mom_1m.iloc[-1]),
"momentum_3m": safe_float(mom_3m.iloc[-1]),
"momentum_6m": safe_float(mom_6m.iloc[-1]),
"volume_momentum": safe_float(volume_momentum.iloc[-1]),
},
}
def calculate_volatility_signals(prices_df):
# Calculate various volatility metrics
returns = prices_df["close"].pct_change()
# Historical volatility
hist_vol = returns.rolling(21).std() * math.sqrt(252)
# Volatility regime detection
vol_ma = hist_vol.rolling(63).mean()
vol_regime = hist_vol / vol_ma
# Volatility mean reversion
vol_z_score = (hist_vol - vol_ma) / hist_vol.rolling(63).std()
# ATR ratio
atr = calculate_atr(prices_df)
atr_ratio = atr / prices_df["close"]
# Generate signal based on volatility regime
current_vol_regime = vol_regime.iloc[-1]
vol_z = vol_z_score.iloc[-1]
if current_vol_regime < 0.8 and vol_z < -1:
signal = "bullish" # Low vol regime, potential for expansion
confidence = min(abs(vol_z) / 3, 1.0)
elif current_vol_regime > 1.2 and vol_z > 1:
signal = "bearish" # High vol regime, potential for contraction
confidence = min(abs(vol_z) / 3, 1.0)
else:
signal = "neutral"
confidence = 0.5
return {
"signal": signal,
"confidence": confidence,
"metrics": {
"historical_volatility": safe_float(hist_vol.iloc[-1]),
"volatility_regime": safe_float(current_vol_regime),
"volatility_z_score": safe_float(vol_z),
"atr_ratio": safe_float(atr_ratio.iloc[-1]),
},
}
def calculate_stat_arb_signals(prices_df):
# Calculate price distribution statistics
returns = prices_df["close"].pct_change()
# Skewness and kurtosis
skew = returns.rolling(63).skew()
kurt = returns.rolling(63).kurt()
# Test for mean reversion using Hurst exponent
hurst = calculate_hurst_exponent(prices_df["close"])
# Correlation analysis
# (would include correlation with related securities in real implementation)
# Generate signal based on statistical properties
if hurst < 0.4 and skew.iloc[-1] > 1:
signal = "bullish"
confidence = (0.5 - hurst) * 2
elif hurst < 0.4 and skew.iloc[-1] < -1:
signal = "bearish"
confidence = (0.5 - hurst) * 2
else:
signal = "neutral"
confidence = 0.5
return {
"signal": signal,
"confidence": confidence,
"metrics": {
"hurst_exponent": safe_float(hurst),
"skewness": safe_float(skew.iloc[-1]),
"kurtosis": safe_float(kurt.iloc[-1]),
},
}
def weighted_signal_combination(signals, weights):
# Convert signals to numeric values
signal_values = {"bullish": 1, "neutral": 0, "bearish": -1}
weighted_sum = 0
total_confidence = 0
for strategy, signal in signals.items():
numeric_signal = signal_values[signal["signal"]]
weight = weights[strategy]
confidence = signal["confidence"]
weighted_sum += numeric_signal * weight * confidence
total_confidence += weight * confidence
# Normalize the weighted sum
if total_confidence > 0:
final_score = weighted_sum / total_confidence
else:
final_score = 0
# Convert back to signal
if final_score > 0.2:
signal = "bullish"
elif final_score < -0.2:
signal = "bearish"
else:
signal = "neutral"
return {"signal": signal, "confidence": abs(final_score)}
def normalize_pandas(obj):
if isinstance(obj, pd.Series):
return obj.tolist()
elif isinstance(obj, pd.DataFrame):
return obj.to_dict("records")
elif isinstance(obj, dict):
return {k: normalize_pandas(v) for k, v in obj.items()}
elif isinstance(obj, (list, tuple)):
return [normalize_pandas(item) for item in obj]
return obj
def calculate_rsi(prices_df: pd.DataFrame, period: int = 14) -> pd.Series:
delta = prices_df["close"].diff()
gain = (delta.where(delta > 0, 0)).fillna(0)
loss = (-delta.where(delta < 0, 0)).fillna(0)
avg_gain = gain.rolling(window=period).mean()
avg_loss = loss.rolling(window=period).mean()
rs = avg_gain / avg_loss
rsi = 100 - (100 / (1 + rs))
return rsi
def calculate_bollinger_bands(prices_df: pd.DataFrame, window: int = 20) -> tuple[pd.Series, pd.Series]:
sma = prices_df["close"].rolling(window).mean()
std_dev = prices_df["close"].rolling(window).std()
upper_band = sma + (std_dev * 2)
lower_band = sma - (std_dev * 2)
return upper_band, lower_band
def calculate_ema(df: pd.DataFrame, window: int) -> pd.Series:
return df["close"].ewm(span=window, adjust=False).mean()
def calculate_adx(df: pd.DataFrame, period: int = 14) -> pd.DataFrame:
# Calculate True Range
df["high_low"] = df["high"] - df["low"]
df["high_close"] = abs(df["high"] - df["close"].shift())
df["low_close"] = abs(df["low"] - df["close"].shift())
df["tr"] = df[["high_low", "high_close", "low_close"]].max(axis=1)
# Calculate Directional Movement
df["up_move"] = df["high"] - df["high"].shift()
df["down_move"] = df["low"].shift() - df["low"]
df["plus_dm"] = np.where((df["up_move"] > df["down_move"]) & (df["up_move"] > 0), df["up_move"], 0)
df["minus_dm"] = np.where((df["down_move"] > df["up_move"]) & (df["down_move"] > 0), df["down_move"], 0)
# Calculate ADX
df["+di"] = 100 * (df["plus_dm"].ewm(span=period).mean() / df["tr"].ewm(span=period).mean())
df["-di"] = 100 * (df["minus_dm"].ewm(span=period).mean() / df["tr"].ewm(span=period).mean())
df["dx"] = 100 * abs(df["+di"] - df["-di"]) / (df["+di"] + df["-di"])
df["adx"] = df["dx"].ewm(span=period).mean()
return df[["adx", "+di", "-di"]]
def calculate_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
high_low = df["high"] - df["low"]
high_close = abs(df["high"] - df["close"].shift())
low_close = abs(df["low"] - df["close"].shift())
ranges = pd.concat([high_low, high_close, low_close], axis=1)
true_range = ranges.max(axis=1)
return true_range.rolling(period).mean()
def calculate_hurst_exponent(price_series: pd.Series, max_lag: int = 20) -> float:
lags = range(2, max_lag)
# Add small epsilon to avoid log(0)
tau = [max(1e-8, np.sqrt(np.std(np.subtract(price_series[lag:], price_series[:-lag])))) for lag in lags]
# Return the Hurst exponent from linear fit
try:
reg = np.polyfit(np.log(lags), np.log(tau), 1)
return reg[0] # Hurst exponent is the slope
except (ValueError, RuntimeWarning):
# Return 0.5 (random walk) if calculation fails
return 0.5 | --- +++ @@ -13,6 +13,16 @@
def safe_float(value, default=0.0):
+ """
+ Safely convert a value to float, handling NaN cases
+
+ Args:
+ value: The value to convert (can be pandas scalar, numpy value, etc.)
+ default: Default value to return if the input is NaN or invalid
+
+ Returns:
+ float: The converted value or default if NaN/invalid
+ """
try:
if pd.isna(value) or np.isnan(value):
return default
@@ -23,6 +33,14 @@
##### Technical Analyst #####
def technical_analyst_agent(state: AgentState, agent_id: str = "technical_analyst_agent"):
+ """
+ Sophisticated technical analysis system that combines multiple trading strategies for multiple tickers:
+ 1. Trend Following
+ 2. Mean Reversion
+ 3. Momentum
+ 4. Volatility Analysis
+ 5. Statistical Arbitrage Signals
+ """
data = state["data"]
start_date = data["start_date"]
end_date = data["end_date"]
@@ -140,6 +158,9 @@
def calculate_trend_signals(prices_df):
+ """
+ Advanced trend following strategy using multiple timeframes and indicators
+ """
# Calculate EMAs for multiple timeframes
ema_8 = calculate_ema(prices_df, 8)
ema_21 = calculate_ema(prices_df, 21)
@@ -176,6 +197,9 @@
def calculate_mean_reversion_signals(prices_df):
+ """
+ Mean reversion strategy using statistical measures and Bollinger Bands
+ """
# Calculate z-score of price relative to moving average
ma_50 = prices_df["close"].rolling(window=50).mean()
std_50 = prices_df["close"].rolling(window=50).std()
@@ -215,6 +239,9 @@
def calculate_momentum_signals(prices_df):
+ """
+ Multi-factor momentum strategy
+ """
# Price momentum
returns = prices_df["close"].pct_change()
mom_1m = returns.rolling(21).sum()
@@ -257,6 +284,9 @@
def calculate_volatility_signals(prices_df):
+ """
+ Volatility-based trading strategy
+ """
# Calculate various volatility metrics
returns = prices_df["close"].pct_change()
@@ -301,6 +331,9 @@
def calculate_stat_arb_signals(prices_df):
+ """
+ Statistical arbitrage signals based on price action analysis
+ """
# Calculate price distribution statistics
returns = prices_df["close"].pct_change()
@@ -337,6 +370,9 @@
def weighted_signal_combination(signals, weights):
+ """
+ Combines multiple trading signals using a weighted approach
+ """
# Convert signals to numeric values
signal_values = {"bullish": 1, "neutral": 0, "bearish": -1}
@@ -369,6 +405,7 @@
def normalize_pandas(obj):
+ """Convert pandas Series/DataFrames to primitive Python types"""
if isinstance(obj, pd.Series):
return obj.tolist()
elif isinstance(obj, pd.DataFrame):
@@ -400,10 +437,30 @@
def calculate_ema(df: pd.DataFrame, window: int) -> pd.Series:
+ """
+ Calculate Exponential Moving Average
+
+ Args:
+ df: DataFrame with price data
+ window: EMA period
+
+ Returns:
+ pd.Series: EMA values
+ """
return df["close"].ewm(span=window, adjust=False).mean()
def calculate_adx(df: pd.DataFrame, period: int = 14) -> pd.DataFrame:
+ """
+ Calculate Average Directional Index (ADX)
+
+ Args:
+ df: DataFrame with OHLC data
+ period: Period for calculations
+
+ Returns:
+ DataFrame with ADX values
+ """
# Calculate True Range
df["high_low"] = df["high"] - df["low"]
df["high_close"] = abs(df["high"] - df["close"].shift())
@@ -427,6 +484,16 @@
def calculate_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
+ """
+ Calculate Average True Range
+
+ Args:
+ df: DataFrame with OHLC data
+ period: Period for ATR calculation
+
+ Returns:
+ pd.Series: ATR values
+ """
high_low = df["high"] - df["low"]
high_close = abs(df["high"] - df["close"].shift())
low_close = abs(df["low"] - df["close"].shift())
@@ -438,6 +505,19 @@
def calculate_hurst_exponent(price_series: pd.Series, max_lag: int = 20) -> float:
+ """
+ Calculate Hurst Exponent to determine long-term memory of time series
+ H < 0.5: Mean reverting series
+ H = 0.5: Random walk
+ H > 0.5: Trending series
+
+ Args:
+ price_series: Array-like price data
+ max_lag: Maximum lag for R/S calculation
+
+ Returns:
+ float: Hurst exponent
+ """
lags = range(2, max_lag)
# Add small epsilon to avoid log(0)
tau = [max(1e-8, np.sqrt(np.std(np.subtract(price_series[lag:], price_series[:-lag])))) for lag in lags]
@@ -448,4 +528,4 @@ return reg[0] # Hurst exponent is the slope
except (ValueError, RuntimeWarning):
# Return 0.5 (random walk) if calculation fails
- return 0.5+ return 0.5
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/technicals.py |
Help me comply with documentation standards |
import requests
import time
from colorama import Fore, Style
import questionary
def ensure_ollama_and_model(model_name: str, ollama_url: str) -> bool:
print(f"{Fore.CYAN}Using Ollama endpoint at {ollama_url}{Style.RESET_ALL}")
# Step 1: Check if Ollama service is available
if not is_ollama_available(ollama_url):
return False
# Step 2: Check if model is already available
available_models = get_available_models(ollama_url)
if model_name in available_models:
print(f"{Fore.GREEN}Model {model_name} is available in the Docker Ollama container.{Style.RESET_ALL}")
return True
# Step 3: Model not available - ask if user wants to download
print(f"{Fore.YELLOW}Model {model_name} is not available in the Docker Ollama container.{Style.RESET_ALL}")
if not questionary.confirm(f"Do you want to download {model_name}?").ask():
print(f"{Fore.RED}Cannot proceed without the model.{Style.RESET_ALL}")
return False
# Step 4: Download the model
return download_model(model_name, ollama_url)
def is_ollama_available(ollama_url: str) -> bool:
try:
response = requests.get(f"{ollama_url}/api/version", timeout=5)
if response.status_code == 200:
return True
print(f"{Fore.RED}Cannot connect to Ollama service at {ollama_url}.{Style.RESET_ALL}")
print(f"{Fore.YELLOW}Make sure the Ollama service is running in your Docker environment.{Style.RESET_ALL}")
return False
except requests.RequestException as e:
print(f"{Fore.RED}Error connecting to Ollama service: {e}{Style.RESET_ALL}")
return False
def get_available_models(ollama_url: str) -> list:
try:
response = requests.get(f"{ollama_url}/api/tags", timeout=5)
if response.status_code == 200:
models = response.json().get("models", [])
return [m["name"] for m in models]
print(f"{Fore.RED}Failed to get available models from Ollama service. Status code: {response.status_code}{Style.RESET_ALL}")
return []
except requests.RequestException as e:
print(f"{Fore.RED}Error getting available models: {e}{Style.RESET_ALL}")
return []
def download_model(model_name: str, ollama_url: str) -> bool:
print(f"{Fore.YELLOW}Downloading model {model_name} to the Docker Ollama container...{Style.RESET_ALL}")
print(f"{Fore.CYAN}This may take some time. Please be patient.{Style.RESET_ALL}")
# Step 1: Initiate the download
try:
response = requests.post(f"{ollama_url}/api/pull", json={"name": model_name}, timeout=10)
if response.status_code != 200:
print(f"{Fore.RED}Failed to initiate model download. Status code: {response.status_code}{Style.RESET_ALL}")
if response.text:
print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")
return False
except requests.RequestException as e:
print(f"{Fore.RED}Error initiating download request: {e}{Style.RESET_ALL}")
return False
# Step 2: Monitor the download progress
print(f"{Fore.CYAN}Download initiated. Checking periodically for completion...{Style.RESET_ALL}")
total_wait_time = 0
max_wait_time = 1800 # 30 minutes max wait
check_interval = 10 # Check every 10 seconds
while total_wait_time < max_wait_time:
# Check if the model has been downloaded
available_models = get_available_models(ollama_url)
if model_name in available_models:
print(f"{Fore.GREEN}Model {model_name} downloaded successfully.{Style.RESET_ALL}")
return True
# Wait before checking again
time.sleep(check_interval)
total_wait_time += check_interval
# Print a status message every minute
if total_wait_time % 60 == 0:
minutes = total_wait_time // 60
print(f"{Fore.CYAN}Download in progress... ({minutes} minute{'s' if minutes != 1 else ''} elapsed){Style.RESET_ALL}")
# If we get here, we've timed out
print(f"{Fore.RED}Timed out waiting for model download to complete after {max_wait_time // 60} minutes.{Style.RESET_ALL}")
return False
def delete_model(model_name: str, ollama_url: str) -> bool:
print(f"{Fore.YELLOW}Deleting model {model_name} from Docker container...{Style.RESET_ALL}")
try:
response = requests.delete(f"{ollama_url}/api/delete", json={"name": model_name}, timeout=10)
if response.status_code == 200:
print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")
return True
else:
print(f"{Fore.RED}Failed to delete model. Status code: {response.status_code}{Style.RESET_ALL}")
if response.text:
print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")
return False
except requests.RequestException as e:
print(f"{Fore.RED}Error deleting model: {e}{Style.RESET_ALL}")
return False | --- +++ @@ -1,3 +1,4 @@+"""Utilities for working with Ollama models in Docker environments"""
import requests
import time
@@ -5,6 +6,7 @@ import questionary
def ensure_ollama_and_model(model_name: str, ollama_url: str) -> bool:
+ """Ensure the Ollama model is available at the target Ollama endpoint."""
print(f"{Fore.CYAN}Using Ollama endpoint at {ollama_url}{Style.RESET_ALL}")
# Step 1: Check if Ollama service is available
@@ -29,6 +31,7 @@
def is_ollama_available(ollama_url: str) -> bool:
+ """Check if Ollama service is available in Docker environment."""
try:
response = requests.get(f"{ollama_url}/api/version", timeout=5)
if response.status_code == 200:
@@ -43,6 +46,7 @@
def get_available_models(ollama_url: str) -> list:
+ """Get list of available models in Docker environment."""
try:
response = requests.get(f"{ollama_url}/api/tags", timeout=5)
if response.status_code == 200:
@@ -57,6 +61,7 @@
def download_model(model_name: str, ollama_url: str) -> bool:
+ """Download a model in Docker environment."""
print(f"{Fore.YELLOW}Downloading model {model_name} to the Docker Ollama container...{Style.RESET_ALL}")
print(f"{Fore.CYAN}This may take some time. Please be patient.{Style.RESET_ALL}")
@@ -101,6 +106,7 @@
def delete_model(model_name: str, ollama_url: str) -> bool:
+ """Delete a model in Docker environment."""
print(f"{Fore.YELLOW}Deleting model {model_name} from Docker container...{Style.RESET_ALL}")
try:
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/utils/docker.py |
Write docstrings describing each step | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import (
get_financial_metrics,
get_market_cap,
search_line_items,
get_insider_trades,
get_company_news,
get_prices,
)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
import statistics
from src.utils.api_key import get_api_key_from_state
class StanleyDruckenmillerSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def stanley_druckenmiller_agent(state: AgentState, agent_id: str = "stanley_druckenmiller_agent"):
data = state["data"]
start_date = data["start_date"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
druck_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
# Include relevant line items for Stan Druckenmiller's approach:
# - Growth & momentum: revenue, EPS, operating_income, ...
# - Valuation: net_income, free_cash_flow, ebit, ebitda
# - Leverage: total_debt, shareholders_equity
# - Liquidity: cash_and_equivalents
financial_line_items = search_line_items(
ticker,
[
"revenue",
"earnings_per_share",
"net_income",
"operating_income",
"gross_margin",
"operating_margin",
"free_cash_flow",
"capital_expenditure",
"cash_and_equivalents",
"total_debt",
"shareholders_equity",
"outstanding_shares",
"ebit",
"ebitda",
],
end_date,
period="annual",
limit=5,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching insider trades")
insider_trades = get_insider_trades(ticker, end_date, limit=50, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching company news")
company_news = get_company_news(ticker, end_date, limit=50, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching recent price data for momentum")
prices = get_prices(ticker, start_date=start_date, end_date=end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing growth & momentum")
growth_momentum_analysis = analyze_growth_and_momentum(financial_line_items, prices)
progress.update_status(agent_id, ticker, "Analyzing sentiment")
sentiment_analysis = analyze_sentiment(company_news)
progress.update_status(agent_id, ticker, "Analyzing insider activity")
insider_activity = analyze_insider_activity(insider_trades)
progress.update_status(agent_id, ticker, "Analyzing risk-reward")
risk_reward_analysis = analyze_risk_reward(financial_line_items, prices)
progress.update_status(agent_id, ticker, "Performing Druckenmiller-style valuation")
valuation_analysis = analyze_druckenmiller_valuation(financial_line_items, market_cap)
# Combine partial scores with weights typical for Druckenmiller:
# 35% Growth/Momentum, 20% Risk/Reward, 20% Valuation,
# 15% Sentiment, 10% Insider Activity = 100%
total_score = (
growth_momentum_analysis["score"] * 0.35
+ risk_reward_analysis["score"] * 0.20
+ valuation_analysis["score"] * 0.20
+ sentiment_analysis["score"] * 0.15
+ insider_activity["score"] * 0.10
)
max_possible_score = 10
# Simple bullish/neutral/bearish signal
if total_score >= 7.5:
signal = "bullish"
elif total_score <= 4.5:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_possible_score,
"growth_momentum_analysis": growth_momentum_analysis,
"sentiment_analysis": sentiment_analysis,
"insider_activity": insider_activity,
"risk_reward_analysis": risk_reward_analysis,
"valuation_analysis": valuation_analysis,
}
progress.update_status(agent_id, ticker, "Generating Stanley Druckenmiller analysis")
druck_output = generate_druckenmiller_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
druck_analysis[ticker] = {
"signal": druck_output.signal,
"confidence": druck_output.confidence,
"reasoning": druck_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=druck_output.reasoning)
# Wrap results in a single message
message = HumanMessage(content=json.dumps(druck_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(druck_analysis, "Stanley Druckenmiller Agent")
state["data"]["analyst_signals"][agent_id] = druck_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_growth_and_momentum(financial_line_items: list, prices: list) -> dict:
if not financial_line_items or len(financial_line_items) < 2:
return {"score": 0, "details": "Insufficient financial data for growth analysis"}
details = []
raw_score = 0 # We'll sum up a maximum of 9 raw points, then scale to 0–10
#
# 1. Revenue Growth (annualized CAGR)
#
revenues = [fi.revenue for fi in financial_line_items if fi.revenue is not None]
if len(revenues) >= 2:
latest_rev = revenues[0]
older_rev = revenues[-1]
num_years = len(revenues) - 1
if older_rev > 0 and latest_rev > 0:
# CAGR formula: (ending_value/beginning_value)^(1/years) - 1
rev_growth = (latest_rev / older_rev) ** (1 / num_years) - 1
if rev_growth > 0.08: # 8% annualized (adjusted for CAGR)
raw_score += 3
details.append(f"Strong annualized revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.04: # 4% annualized
raw_score += 2
details.append(f"Moderate annualized revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.01: # 1% annualized
raw_score += 1
details.append(f"Slight annualized revenue growth: {rev_growth:.1%}")
else:
details.append(f"Minimal/negative revenue growth: {rev_growth:.1%}")
else:
details.append("Older revenue is zero/negative; can't compute revenue growth.")
else:
details.append("Not enough revenue data points for growth calculation.")
#
# 2. EPS Growth (annualized CAGR)
#
eps_values = [fi.earnings_per_share for fi in financial_line_items if fi.earnings_per_share is not None]
if len(eps_values) >= 2:
latest_eps = eps_values[0]
older_eps = eps_values[-1]
num_years = len(eps_values) - 1
# Calculate CAGR for positive EPS values
if older_eps > 0 and latest_eps > 0:
# CAGR formula for EPS
eps_growth = (latest_eps / older_eps) ** (1 / num_years) - 1
if eps_growth > 0.08: # 8% annualized (adjusted for CAGR)
raw_score += 3
details.append(f"Strong annualized EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.04: # 4% annualized
raw_score += 2
details.append(f"Moderate annualized EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.01: # 1% annualized
raw_score += 1
details.append(f"Slight annualized EPS growth: {eps_growth:.1%}")
else:
details.append(f"Minimal/negative annualized EPS growth: {eps_growth:.1%}")
else:
details.append("Older EPS is near zero; skipping EPS growth calculation.")
else:
details.append("Not enough EPS data points for growth calculation.")
#
# 3. Price Momentum
#
# We'll give up to 3 points for strong momentum
if prices and len(prices) > 30:
sorted_prices = sorted(prices, key=lambda p: p.time)
close_prices = [p.close for p in sorted_prices if p.close is not None]
if len(close_prices) >= 2:
start_price = close_prices[0]
end_price = close_prices[-1]
if start_price > 0:
pct_change = (end_price - start_price) / start_price
if pct_change > 0.50:
raw_score += 3
details.append(f"Very strong price momentum: {pct_change:.1%}")
elif pct_change > 0.20:
raw_score += 2
details.append(f"Moderate price momentum: {pct_change:.1%}")
elif pct_change > 0:
raw_score += 1
details.append(f"Slight positive momentum: {pct_change:.1%}")
else:
details.append(f"Negative price momentum: {pct_change:.1%}")
else:
details.append("Invalid start price (<= 0); can't compute momentum.")
else:
details.append("Insufficient price data for momentum calculation.")
else:
details.append("Not enough recent price data for momentum analysis.")
# We assigned up to 3 points each for:
# revenue growth, eps growth, momentum
# => max raw_score = 9
# Scale to 0–10
final_score = min(10, (raw_score / 9) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_insider_activity(insider_trades: list) -> dict:
# Default is neutral (5/10).
score = 5
details = []
if not insider_trades:
details.append("No insider trades data; defaulting to neutral")
return {"score": score, "details": "; ".join(details)}
buys, sells = 0, 0
for trade in insider_trades:
# Use transaction_shares to determine if it's a buy or sell
# Negative shares = sell, positive shares = buy
if trade.transaction_shares is not None:
if trade.transaction_shares > 0:
buys += 1
elif trade.transaction_shares < 0:
sells += 1
total = buys + sells
if total == 0:
details.append("No buy/sell transactions found; neutral")
return {"score": score, "details": "; ".join(details)}
buy_ratio = buys / total
if buy_ratio > 0.7:
# Heavy buying => +3 points from the neutral 5 => 8
score = 8
details.append(f"Heavy insider buying: {buys} buys vs. {sells} sells")
elif buy_ratio > 0.4:
# Moderate buying => +1 => 6
score = 6
details.append(f"Moderate insider buying: {buys} buys vs. {sells} sells")
else:
# Low insider buying => -1 => 4
score = 4
details.append(f"Mostly insider selling: {buys} buys vs. {sells} sells")
return {"score": score, "details": "; ".join(details)}
def analyze_sentiment(news_items: list) -> dict:
if not news_items:
return {"score": 5, "details": "No news data; defaulting to neutral sentiment"}
negative_keywords = ["lawsuit", "fraud", "negative", "downturn", "decline", "investigation", "recall"]
negative_count = 0
for news in news_items:
title_lower = (news.title or "").lower()
if any(word in title_lower for word in negative_keywords):
negative_count += 1
details = []
if negative_count > len(news_items) * 0.3:
# More than 30% negative => somewhat bearish => 3/10
score = 3
details.append(f"High proportion of negative headlines: {negative_count}/{len(news_items)}")
elif negative_count > 0:
# Some negativity => 6/10
score = 6
details.append(f"Some negative headlines: {negative_count}/{len(news_items)}")
else:
# Mostly positive => 8/10
score = 8
details.append("Mostly positive/neutral headlines")
return {"score": score, "details": "; ".join(details)}
def analyze_risk_reward(financial_line_items: list, prices: list) -> dict:
if not financial_line_items or not prices:
return {"score": 0, "details": "Insufficient data for risk-reward analysis"}
details = []
raw_score = 0 # We'll accumulate up to 6 raw points, then scale to 0-10
#
# 1. Debt-to-Equity
#
debt_values = [fi.total_debt for fi in financial_line_items if fi.total_debt is not None]
equity_values = [fi.shareholders_equity for fi in financial_line_items if fi.shareholders_equity is not None]
if debt_values and equity_values and len(debt_values) == len(equity_values) and len(debt_values) > 0:
recent_debt = debt_values[0]
recent_equity = equity_values[0] if equity_values[0] else 1e-9
de_ratio = recent_debt / recent_equity
if de_ratio < 0.3:
raw_score += 3
details.append(f"Low debt-to-equity: {de_ratio:.2f}")
elif de_ratio < 0.7:
raw_score += 2
details.append(f"Moderate debt-to-equity: {de_ratio:.2f}")
elif de_ratio < 1.5:
raw_score += 1
details.append(f"Somewhat high debt-to-equity: {de_ratio:.2f}")
else:
details.append(f"High debt-to-equity: {de_ratio:.2f}")
else:
details.append("No consistent debt/equity data available.")
#
# 2. Price Volatility
#
if len(prices) > 10:
sorted_prices = sorted(prices, key=lambda p: p.time)
close_prices = [p.close for p in sorted_prices if p.close is not None]
if len(close_prices) > 10:
daily_returns = []
for i in range(1, len(close_prices)):
prev_close = close_prices[i - 1]
if prev_close > 0:
daily_returns.append((close_prices[i] - prev_close) / prev_close)
if daily_returns:
stdev = statistics.pstdev(daily_returns) # population stdev
if stdev < 0.01:
raw_score += 3
details.append(f"Low volatility: daily returns stdev {stdev:.2%}")
elif stdev < 0.02:
raw_score += 2
details.append(f"Moderate volatility: daily returns stdev {stdev:.2%}")
elif stdev < 0.04:
raw_score += 1
details.append(f"High volatility: daily returns stdev {stdev:.2%}")
else:
details.append(f"Very high volatility: daily returns stdev {stdev:.2%}")
else:
details.append("Insufficient daily returns data for volatility calc.")
else:
details.append("Not enough close-price data points for volatility analysis.")
else:
details.append("Not enough price data for volatility analysis.")
# raw_score out of 6 => scale to 0–10
final_score = min(10, (raw_score / 6) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_druckenmiller_valuation(financial_line_items: list, market_cap: float | None) -> dict:
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data to perform valuation"}
details = []
raw_score = 0
# Gather needed data
net_incomes = [fi.net_income for fi in financial_line_items if fi.net_income is not None]
fcf_values = [fi.free_cash_flow for fi in financial_line_items if fi.free_cash_flow is not None]
ebit_values = [fi.ebit for fi in financial_line_items if fi.ebit is not None]
ebitda_values = [fi.ebitda for fi in financial_line_items if fi.ebitda is not None]
# For EV calculation, let's get the most recent total_debt & cash
debt_values = [fi.total_debt for fi in financial_line_items if fi.total_debt is not None]
cash_values = [fi.cash_and_equivalents for fi in financial_line_items if fi.cash_and_equivalents is not None]
recent_debt = debt_values[0] if debt_values else 0
recent_cash = cash_values[0] if cash_values else 0
enterprise_value = market_cap + recent_debt - recent_cash
# 1) P/E
recent_net_income = net_incomes[0] if net_incomes else None
if recent_net_income and recent_net_income > 0:
pe = market_cap / recent_net_income
pe_points = 0
if pe < 15:
pe_points = 2
details.append(f"Attractive P/E: {pe:.2f}")
elif pe < 25:
pe_points = 1
details.append(f"Fair P/E: {pe:.2f}")
else:
details.append(f"High or Very high P/E: {pe:.2f}")
raw_score += pe_points
else:
details.append("No positive net income for P/E calculation")
# 2) P/FCF
recent_fcf = fcf_values[0] if fcf_values else None
if recent_fcf and recent_fcf > 0:
pfcf = market_cap / recent_fcf
pfcf_points = 0
if pfcf < 15:
pfcf_points = 2
details.append(f"Attractive P/FCF: {pfcf:.2f}")
elif pfcf < 25:
pfcf_points = 1
details.append(f"Fair P/FCF: {pfcf:.2f}")
else:
details.append(f"High/Very high P/FCF: {pfcf:.2f}")
raw_score += pfcf_points
else:
details.append("No positive free cash flow for P/FCF calculation")
# 3) EV/EBIT
recent_ebit = ebit_values[0] if ebit_values else None
if enterprise_value > 0 and recent_ebit and recent_ebit > 0:
ev_ebit = enterprise_value / recent_ebit
ev_ebit_points = 0
if ev_ebit < 15:
ev_ebit_points = 2
details.append(f"Attractive EV/EBIT: {ev_ebit:.2f}")
elif ev_ebit < 25:
ev_ebit_points = 1
details.append(f"Fair EV/EBIT: {ev_ebit:.2f}")
else:
details.append(f"High EV/EBIT: {ev_ebit:.2f}")
raw_score += ev_ebit_points
else:
details.append("No valid EV/EBIT because EV <= 0 or EBIT <= 0")
# 4) EV/EBITDA
recent_ebitda = ebitda_values[0] if ebitda_values else None
if enterprise_value > 0 and recent_ebitda and recent_ebitda > 0:
ev_ebitda = enterprise_value / recent_ebitda
ev_ebitda_points = 0
if ev_ebitda < 10:
ev_ebitda_points = 2
details.append(f"Attractive EV/EBITDA: {ev_ebitda:.2f}")
elif ev_ebitda < 18:
ev_ebitda_points = 1
details.append(f"Fair EV/EBITDA: {ev_ebitda:.2f}")
else:
details.append(f"High EV/EBITDA: {ev_ebitda:.2f}")
raw_score += ev_ebitda_points
else:
details.append("No valid EV/EBITDA because EV <= 0 or EBITDA <= 0")
# We have up to 2 points for each of the 4 metrics => 8 raw points max
# Scale raw_score to 0–10
final_score = min(10, (raw_score / 8) * 10)
return {"score": final_score, "details": "; ".join(details)}
def generate_druckenmiller_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> StanleyDruckenmillerSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Stanley Druckenmiller AI agent, making investment decisions using his principles:
1. Seek asymmetric risk-reward opportunities (large upside, limited downside).
2. Emphasize growth, momentum, and market sentiment.
3. Preserve capital by avoiding major drawdowns.
4. Willing to pay higher valuations for true growth leaders.
5. Be aggressive when conviction is high.
6. Cut losses quickly if the thesis changes.
Rules:
- Reward companies showing strong revenue/earnings growth and positive stock momentum.
- Evaluate sentiment and insider activity as supportive or contradictory signals.
- Watch out for high leverage or extreme volatility that threatens capital.
- Output a JSON object with signal, confidence, and a reasoning string.
When providing your reasoning, be thorough and specific by:
1. Explaining the growth and momentum metrics that most influenced your decision
2. Highlighting the risk-reward profile with specific numerical evidence
3. Discussing market sentiment and catalysts that could drive price action
4. Addressing both upside potential and downside risks
5. Providing specific valuation context relative to growth prospects
6. Using Stanley Druckenmiller's decisive, momentum-focused, and conviction-driven voice
For example, if bullish: "The company shows exceptional momentum with revenue accelerating from 22% to 35% YoY and the stock up 28% over the past three months. Risk-reward is highly asymmetric with 70% upside potential based on FCF multiple expansion and only 15% downside risk given the strong balance sheet with 3x cash-to-debt. Insider buying and positive market sentiment provide additional tailwinds..."
For example, if bearish: "Despite recent stock momentum, revenue growth has decelerated from 30% to 12% YoY, and operating margins are contracting. The risk-reward proposition is unfavorable with limited 10% upside potential against 40% downside risk. The competitive landscape is intensifying, and insider selling suggests waning confidence. I'm seeing better opportunities elsewhere with more favorable setups..."
""",
),
(
"human",
"""Based on the following analysis, create a Druckenmiller-style investment signal.
Analysis Data for {ticker}:
{analysis_data}
Return the trading signal in this JSON format:
{{
"signal": "bullish/bearish/neutral",
"confidence": float (0-100),
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def create_default_signal():
return StanleyDruckenmillerSignal(
signal="neutral",
confidence=0.0,
reasoning="Error in analysis, defaulting to neutral"
)
return call_llm(
prompt=prompt,
pydantic_model=StanleyDruckenmillerSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_signal,
) | --- +++ @@ -24,6 +24,15 @@
def stanley_druckenmiller_agent(state: AgentState, agent_id: str = "stanley_druckenmiller_agent"):
+ """
+ Analyzes stocks using Stanley Druckenmiller's investing principles:
+ - Seeking asymmetric risk-reward opportunities
+ - Emphasizing growth, momentum, and sentiment
+ - Willing to be aggressive if conditions are favorable
+ - Focus on preserving capital by avoiding high-risk, low-reward bets
+
+ Returns a bullish/bearish/neutral signal with confidence and reasoning.
+ """
data = state["data"]
start_date = data["start_date"]
end_date = data["end_date"]
@@ -155,6 +164,12 @@
def analyze_growth_and_momentum(financial_line_items: list, prices: list) -> dict:
+ """
+ Evaluate:
+ - Revenue Growth (YoY)
+ - EPS Growth (YoY)
+ - Price Momentum
+ """
if not financial_line_items or len(financial_line_items) < 2:
return {"score": 0, "details": "Insufficient financial data for growth analysis"}
@@ -256,6 +271,12 @@
def analyze_insider_activity(insider_trades: list) -> dict:
+ """
+ Simple insider-trade analysis:
+ - If there's heavy insider buying, we nudge the score up.
+ - If there's mostly selling, we reduce it.
+ - Otherwise, neutral.
+ """
# Default is neutral (5/10).
score = 5
details = []
@@ -297,6 +318,9 @@
def analyze_sentiment(news_items: list) -> dict:
+ """
+ Basic news sentiment: negative keyword check vs. overall volume.
+ """
if not news_items:
return {"score": 5, "details": "No news data; defaulting to neutral sentiment"}
@@ -325,6 +349,12 @@
def analyze_risk_reward(financial_line_items: list, prices: list) -> dict:
+ """
+ Assesses risk via:
+ - Debt-to-Equity
+ - Price Volatility
+ Aims for strong upside with contained downside.
+ """
if not financial_line_items or not prices:
return {"score": 0, "details": "Insufficient data for risk-reward analysis"}
@@ -393,6 +423,14 @@
def analyze_druckenmiller_valuation(financial_line_items: list, market_cap: float | None) -> dict:
+ """
+ Druckenmiller is willing to pay up for growth, but still checks:
+ - P/E
+ - P/FCF
+ - EV/EBIT
+ - EV/EBITDA
+ Each can yield up to 2 points => max 8 raw points => scale to 0–10.
+ """
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data to perform valuation"}
@@ -494,6 +532,9 @@ state: AgentState,
agent_id: str,
) -> StanleyDruckenmillerSignal:
+ """
+ Generates a JSON signal in the style of Stanley Druckenmiller.
+ """
template = ChatPromptTemplate.from_messages(
[
(
@@ -558,4 +599,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/stanley_druckenmiller.py |
Add inline docstrings for readability | # coding=utf-8
import json
import os
import re
import smtplib
import time
from datetime import datetime
from email.header import Header
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.utils import formataddr, formatdate, make_msgid
from pathlib import Path
from typing import Any, Dict, List, Optional
from urllib.parse import urlparse
import requests
import yaml
from trendradar.core.loader import _load_webhook_config, _load_notification_config
from trendradar.notification.batch import (
truncate_to_bytes,
get_batch_header,
get_max_batch_header_size,
add_batch_headers,
)
from trendradar.notification.formatters import strip_markdown
from trendradar.notification.senders import SMTP_CONFIGS
from ..utils.errors import MCPError, InvalidParameterError
# ==================== 渠道启用判断规则 ====================
# 每个渠道需要哪些配置项都非空才算"已配置"
# 注意：NTFY_SERVER_URL 在 loader 中有默认值 "https://ntfy.sh"，不作为判断依据
_CHANNEL_REQUIREMENTS = {
"feishu": ["FEISHU_WEBHOOK_URL"],
"dingtalk": ["DINGTALK_WEBHOOK_URL"],
"wework": ["WEWORK_WEBHOOK_URL"],
"telegram": ["TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID"],
"email": ["EMAIL_FROM", "EMAIL_PASSWORD", "EMAIL_TO"],
"ntfy": ["NTFY_TOPIC"],
"bark": ["BARK_URL"],
"slack": ["SLACK_WEBHOOK_URL"],
"generic_webhook": ["GENERIC_WEBHOOK_URL"],
}
# 渠道显示名称
_CHANNEL_NAMES = {
"feishu": "飞书",
"dingtalk": "钉钉",
"wework": "企业微信",
"telegram": "Telegram",
"email": "邮件",
"ntfy": "ntfy",
"bark": "Bark",
"slack": "Slack",
"generic_webhook": "通用 Webhook",
}
# ==================== 批次处理配置 ====================
# 各渠道最大批次字节数的默认值
# 运行时从 config.yaml → advanced.batch_size 读取覆盖
_CHANNEL_BATCH_SIZES_DEFAULT = {
"feishu": 30000, # config.yaml: advanced.batch_size.feishu
"dingtalk": 20000, # config.yaml: advanced.batch_size.dingtalk
"wework": 4000, # config.yaml: advanced.batch_size.default
"telegram": 4000, # config.yaml: advanced.batch_size.default
"email": 0, # 邮件无字节限制，不分批
"ntfy": 3800, # 严格 4KB 限制（ntfy 代码默认值）
"bark": 4000, # config.yaml: advanced.batch_size.bark
"slack": 4000, # config.yaml: advanced.batch_size.slack
"generic_webhook": 4000,
}
# 显示最新消息在前的渠道，批次需反序发送
_REVERSE_BATCH_CHANNELS = {"ntfy", "bark"}
# 批次发送间隔默认值（秒），运行时从 config.yaml → advanced.batch_send_interval 读取
_BATCH_INTERVAL_DEFAULT = 3.0
# ==================== 批次处理 ====================
# truncate_to_bytes, get_batch_header, get_max_batch_header_size,
# add_batch_headers 复用自 trendradar.notification.batch
def _split_text_into_batches(text: str, max_bytes: int) -> List[str]:
if max_bytes <= 0 or len(text.encode("utf-8")) <= max_bytes:
return [text]
# 按段落分割
paragraphs = text.split("\n\n")
batches = []
current = ""
for para in paragraphs:
candidate = f"{current}\n\n{para}" if current else para
if len(candidate.encode("utf-8")) <= max_bytes:
current = candidate
else:
# 当前段落放不下，先保存已有内容
if current:
batches.append(current)
current = ""
# 检查单个段落是否超限
if len(para.encode("utf-8")) <= max_bytes:
current = para
else:
# 段落本身超限，按行拆分
lines = para.split("\n")
for line in lines:
candidate = f"{current}\n{line}" if current else line
if len(candidate.encode("utf-8")) <= max_bytes:
current = candidate
else:
if current:
batches.append(current)
current = ""
# 单行超限，循环截断直到处理完
if len(line.encode("utf-8")) > max_bytes:
remaining = line
while remaining:
chunk = truncate_to_bytes(remaining, max_bytes)
if not chunk:
break
batches.append(chunk)
# 移除已截断的部分
remaining = remaining[len(chunk):]
else:
current = line
if current:
batches.append(current)
return batches if batches else [text]
def _format_for_channel(message: str, channel_id: str) -> str:
if channel_id == "feishu":
return _adapt_markdown_for_feishu(message)
elif channel_id == "dingtalk":
return _adapt_markdown_for_dingtalk(message)
elif channel_id == "wework":
return _adapt_markdown_for_wework(message)
elif channel_id == "telegram":
return _markdown_to_telegram_html(message)
elif channel_id == "ntfy":
return _adapt_markdown_for_ntfy(message)
elif channel_id == "bark":
return _adapt_markdown_for_bark(message)
elif channel_id == "slack":
return _convert_markdown_to_slack(message)
else:
# email, generic_webhook: 保持原始 Markdown
return message
def _prepare_batches(message: str, channel_id: str, batch_sizes: Dict = None) -> List[str]:
sizes = batch_sizes or _CHANNEL_BATCH_SIZES_DEFAULT
max_bytes = sizes.get(channel_id, sizes.get("default", 4000))
if max_bytes <= 0:
# 无字节限制（如 email），返回原始文本
return [message]
formatted = _format_for_channel(message, channel_id)
# 预留批次头部空间后分割
header_reserve = get_max_batch_header_size(channel_id)
batches = _split_text_into_batches(formatted, max_bytes - header_reserve)
# 添加批次头部（单批时不添加）
batches = add_batch_headers(batches, channel_id, max_bytes)
# ntfy/Bark 反序发送（客户端显示最新在前）
if channel_id in _REVERSE_BATCH_CHANNELS and len(batches) > 1:
batches = list(reversed(batches))
return batches
CHANNEL_FORMAT_GUIDES = {
"feishu": {
"name": "飞书",
"format": "Markdown（卡片消息）",
"max_length": "约 29000 字节",
"supported": [
"**粗体**",
"[链接文本](URL)",
"<font color='red/green/grey/orange/blue'>彩色文本</font>",
"---（分割线）",
"换行分隔段落",
],
"unsupported": [
"# 标题语法（不渲染为标题样式）",
"> 引用块",
"表格 / 图片嵌入",
],
"prompt": (
"飞书卡片 Markdown 格式化策略：\n"
"1. 用 **粗体** 作小标题和重点词\n"
"2. 用 <font color='red'>红色</font> 标记紧急/重要内容\n"
"3. 用 <font color='grey'>灰色</font> 标记辅助信息（时间、来源）\n"
"4. 用 <font color='orange'>橙色</font> 标记警告\n"
"5. 用 <font color='green'>绿色</font> 标记正面/成功信息\n"
"6. 用 [文本](URL) 添加可点击链接\n"
"7. 用 --- 分割不同主题区域\n"
"8. 不要用 # 标题语法（卡片内不渲染）\n"
"9. 不要用 > 引用语法\n"
"10. 用换行 + 粗体模拟层级结构"
),
},
"dingtalk": {
"name": "钉钉",
"format": "Markdown",
"max_length": "约 20000 字节",
"supported": [
"### 三级标题 / #### 四级标题",
"**粗体**",
"[链接文本](URL)",
"> 引用块",
"---（分割线）",
"- 无序列表 / 1. 有序列表",
],
"unsupported": [
"# 一级标题 / ## 二级标题（可能不渲染）",
"<font> 彩色文本",
"~~删除线~~",
"表格 / 图片嵌入",
],
"prompt": (
"钉钉 Markdown 格式化策略：\n"
"1. 用 ### 或 #### 作章节标题（不用 # 和 ##）\n"
"2. 用 **粗体** 突出关键词和数据\n"
"3. 用 > 引用块展示备注或补充说明\n"
"4. 用 --- 分割不同主题区域\n"
"5. 用 [文本](URL) 添加可点击链接\n"
"6. 用有序列表（1. 2. 3.）组织要点\n"
"7. 不要用 <font> 颜色标签（钉钉不支持）\n"
"8. 不要用删除线语法\n"
"9. 标题和正文之间加空行提升可读性"
),
},
"wework": {
"name": "企业微信",
"format": "Markdown（群机器人）/ 纯文本（个人微信）",
"max_length": "约 4000 字节",
"supported": [
"**粗体**",
"[链接文本](URL)",
"> 引用块（仅首行生效）",
],
"unsupported": [
"# 标题语法",
"---（水平分割线）",
"<font> 彩色文本",
"~~删除线~~",
"表格 / 图片嵌入 / 有序列表",
],
"prompt": (
"企业微信 Markdown 格式化策略：\n"
"1. 用 **粗体** 作小标题和重点词\n"
"2. 用 [文本](URL) 添加可点击链接\n"
"3. 用 > 引用块展示备注（仅首行生效）\n"
"4. 内容要简洁，受 4KB 限制\n"
"5. 不要用 # 标题语法（不渲染）\n"
"6. 不要用 ---（不渲染），用多个换行分隔区域\n"
"7. 不要用 <font> 颜色标签\n"
"8. 不要用删除线和有序列表\n"
"9. 用换行 + 粗体模拟层级结构\n"
"10. 个人微信模式下所有格式被剥离为纯文本"
),
},
"telegram": {
"name": "Telegram",
"format": "HTML（自动从 Markdown 转换）",
"max_length": "约 4096 字符",
"supported": [
"<b>粗体</b>（从 **粗体** 转换）",
"<i>斜体</i>（从 *斜体* 转换）",
"<s>删除线</s>（从 ~~删除线~~ 转换）",
"<code>行内代码</code>（从 `代码` 转换）",
"<a href='URL'>链接</a>（从 [文本](URL) 转换）",
"<blockquote>引用块</blockquote>（从 > 引用 转换）",
],
"unsupported": [
"# 标题语法（自动剥离 # 前缀）",
"---（分割线，自动剥离）",
"<font> 彩色文本（自动剥离）",
"表格 / 图片嵌入",
],
"prompt": (
"Telegram HTML 格式化策略（输入仍为 Markdown，自动转换为 HTML）：\n"
"1. 用 **粗体** 突出关键词（转为 <b>）\n"
"2. 用 *斜体* 标记辅助信息（转为 <i>）\n"
"3. 用 `代码` 标记数据值/时间（转为 <code>）\n"
"4. 用 [文本](URL) 添加链接（转为 <a>）\n"
"5. 用 > 开头的行作引用块（转为 <blockquote>）\n"
"6. 不要用 # 标题（Telegram 无标题样式，仅剥离 #）\n"
"7. 不要用 --- 分割线（被剥离），用空行分隔\n"
"8. 不要用 <font> 颜色标签（被剥离）\n"
"9. 内容受 4096 字符限制，保持简洁\n"
"10. 链接默认禁用预览，适合信息密集型消息"
),
},
"email": {
"name": "邮件",
"format": "HTML（完整网页，从 Markdown 转换）",
"max_length": "无硬限制",
"supported": [
"# / ## / ### 标题（转为 <h1>/<h2>/<h3>）",
"**粗体** / *斜体* / ~~删除线~~",
"[链接文本](URL)",
"`行内代码`",
"---（水平分割线）",
],
"unsupported": [
"<font> 彩色文本（转义显示）",
"复杂表格",
],
"prompt": (
"邮件 HTML 格式化策略（输入为 Markdown，自动转换为带样式 HTML）：\n"
"1. 用 # / ## / ### 创建清晰的标题层级\n"
"2. 用 **粗体** 和 *斜体* 增强可读性\n"
"3. 用 [文本](URL) 添加链接（蓝色可点击）\n"
"4. 用 --- 分割不同章节\n"
"5. 用 `代码` 标记技术术语或数据\n"
"6. 可以写较长内容，邮件无严格长度限制\n"
"7. 邮件主题自动追加日期时间\n"
"8. 自动附带纯文本备用版本"
),
},
"ntfy": {
"name": "ntfy",
"format": "Markdown（原生支持）",
"max_length": "约 3800 字节（单条 4KB 限制）",
"supported": [
"**粗体** / *斜体*",
"[链接文本](URL)",
"> 引用块",
"`行内代码`",
"- 列表",
],
"unsupported": [
"# 标题语法（渲染取决于客户端）",
"<font> 彩色文本",
"---（渲染取决于客户端）",
"表格",
],
"prompt": (
"ntfy Markdown 格式化策略：\n"
"1. 用 **粗体** 突出关键词\n"
"2. 用 [文本](URL) 添加可点击链接\n"
"3. 用 > 引用块展示备注\n"
"4. 用 `代码` 标记数据值\n"
"5. 内容要精炼，受 4KB 限制\n"
"6. 不要用 <font> 颜色标签（无效）\n"
"7. 不要依赖 # 标题和 --- 分割线\n"
"8. 用空行和粗体组织信息层级"
),
},
"bark": {
"name": "Bark",
"format": "Markdown（iOS 推送）",
"max_length": "约 3600 字节（APNs 4KB 限制）",
"supported": [
"**粗体**",
"[链接文本](URL)",
"基础文本格式",
],
"unsupported": [
"# 标题语法",
"<font> 彩色文本",
"---（分割线）",
"> 引用块",
"复杂嵌套格式",
],
"prompt": (
"Bark 格式化策略（iOS 推送通知）：\n"
"1. 内容要极度精简，移动端阅读场景\n"
"2. 用 **粗体** 标记核心信息\n"
"3. 用 [文本](URL) 添加链接\n"
"4. 不要用标题/颜色/引用等复杂格式\n"
"5. 受 APNs 4KB 限制，控制内容长度\n"
"6. 层级结构靠缩进和换行实现\n"
"7. 适合简短通知和摘要，不适合长文"
),
},
"slack": {
"name": "Slack",
"format": "mrkdwn（Slack 专有格式，自动从 Markdown 转换）",
"max_length": "约 4000 字节",
"supported": [
"*粗体*（从 **粗体** 转换）",
"_斜体_",
"~删除线~（从 ~~删除线~~ 转换）",
"<URL|链接文本>（从 [文本](URL) 转换）",
"`行内代码`",
"```代码块```",
"> 引用块",
],
"unsupported": [
"# 标题语法（剥离为粗体）",
"<font> 彩色文本",
"--- 分割线（渲染不稳定）",
"表格",
],
"prompt": (
"Slack mrkdwn 格式化策略（输入为 Markdown，自动转换为 mrkdwn）：\n"
"1. 用 **粗体** 突出关键词（转为 *粗体*）\n"
"2. 用 ~~删除线~~ 标记过时信息（转为 ~删除线~）\n"
"3. 用 [文本](URL) 添加链接（转为 <URL|文本>）\n"
"4. 用 > 引用块展示备注\n"
"5. 用 `代码` 标记数据值\n"
"6. 不要用 # 标题（Slack 无标题样式）\n"
"7. 不要用 <font> 颜色标签\n"
"8. 用空行和粗体组织信息层级"
),
},
"generic_webhook": {
"name": "通用 Webhook",
"format": "Markdown（或自定义模板）",
"max_length": "约 4000 字节",
"supported": ["标准 Markdown 语法"],
"unsupported": ["取决于接收端"],
"prompt": (
"通用 Webhook 格式化策略：\n"
"1. 使用标准 Markdown 格式\n"
"2. 避免使用特殊平台专有语法\n"
"3. 如配置了自定义模板，内容会填充到 {content} 占位符"
),
},
}
# ==================== 渠道 Markdown 适配 ====================
def _adapt_markdown_for_feishu(text: str) -> str:
# 将 # 标题转换为粗体（飞书卡片不渲染标题语法）
text = re.sub(r'^#{1,6}\s+(.+)$', r'**\1**', text, flags=re.MULTILINE)
# 去除引用语法前缀（飞书不支持）
text = re.sub(r'^>\s*', '', text, flags=re.MULTILINE)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
def _adapt_markdown_for_dingtalk(text: str) -> str:
# 去除 <font> 标签（钉钉不支持，保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 和 ## 标题降级为 ### （钉钉仅支持 ### 和 ####）
text = re.sub(r'^##\s+(.+)$', r'### \1', text, flags=re.MULTILINE)
text = re.sub(r'^#\s+(.+)$', r'### \1', text, flags=re.MULTILINE)
# 去除删除线语法（钉钉不支持）
text = re.sub(r'~~(.+?)~~', r'\1', text)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
def _adapt_markdown_for_wework(text: str) -> str:
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体（企业微信不渲染标题语法）
text = re.sub(r'^#{1,6}\s+(.+)$', r'**\1**', text, flags=re.MULTILINE)
# 将 --- 分割线替换为多个换行（企业微信不渲染水平线）
text = re.sub(r'^[\-\*]{3,}\s*$', '\n\n', text, flags=re.MULTILINE)
# 去除删除线语法（企业微信不支持）
text = re.sub(r'~~(.+?)~~', r'\1', text)
# 清理多余空行（保留最多两个）
text = re.sub(r'\n{4,}', '\n\n\n', text)
return text.strip()
def _adapt_markdown_for_ntfy(text: str) -> str:
# 去除 <font> 标签（ntfy 不支持）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
def _adapt_markdown_for_bark(text: str) -> str:
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体
text = re.sub(r'^#{1,6}\s+(.+)$', r'**\1**', text, flags=re.MULTILINE)
# 将 --- 替换为换行
text = re.sub(r'^[\-\*]{3,}\s*$', '\n', text, flags=re.MULTILINE)
# 去除引用语法
text = re.sub(r'^>\s*', '', text, flags=re.MULTILINE)
# 去除删除线语法
text = re.sub(r'~~(.+?)~~', r'\1', text)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
# ==================== 格式转换 ====================
def _markdown_to_telegram_html(text: str) -> str:
# 预处理：去除 <font> 标签（Telegram 不支持，保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
lines = text.split('\n')
result_lines = []
in_blockquote = False
for line in lines:
# 将标题符号 # ## ### 转换为粗体
header_match = re.match(r'^(#{1,6})\s+(.+)$', line)
if header_match:
line = f'**{header_match.group(2)}**'
# 去除水平分割线
if re.match(r'^[\-\*]{3,}\s*$', line):
if in_blockquote:
result_lines.append('</blockquote>')
in_blockquote = False
line = ''
# 处理引用块 > text → <blockquote>text</blockquote>
quote_match = re.match(r'^>\s*(.*)$', line)
if quote_match:
if not in_blockquote:
result_lines.append('<blockquote>')
in_blockquote = True
result_lines.append(quote_match.group(1))
continue
elif in_blockquote:
result_lines.append('</blockquote>')
in_blockquote = False
result_lines.append(line)
if in_blockquote:
result_lines.append('</blockquote>')
text = '\n'.join(result_lines)
# 转义 HTML 实体（在标记替换之前，但在 blockquote 标签之后）
# 分段处理：保留已生成的 HTML 标签
parts = re.split(r'(</?blockquote>)', text)
escaped_parts = []
for part in parts:
if part in ('<blockquote>', '</blockquote>'):
escaped_parts.append(part)
else:
part = part.replace('&', '&')
part = part.replace('<', '<')
part = part.replace('>', '>')
escaped_parts.append(part)
text = ''.join(escaped_parts)
# 转换链接 [text](url) → <a href="url">text</a>
text = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2">\1</a>', text)
# 转换粗体 **text** → <b>text</b>
text = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', text)
# 转换斜体 *text* → <i>text</i>
text = re.sub(r'\*(.+?)\*', r'<i>\1</i>', text)
# 转换删除线 ~~text~~ → <s>text</s>
text = re.sub(r'~~(.+?)~~', r'<s>\1</s>', text)
# 转换行内代码 `code` → <code>code</code>
text = re.sub(r'`(.+?)`', r'<code>\1</code>', text)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
def _convert_markdown_to_slack(text: str) -> str:
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体（Slack 无标题样式）
text = re.sub(r'^#{1,6}\s+(.+)$', r'**\1**', text, flags=re.MULTILINE)
# 去除 --- 分割线（Slack 渲染不稳定）
text = re.sub(r'^[\-\*]{3,}\s*$', '', text, flags=re.MULTILINE)
# 转换链接格式: [文本](url) → <url|文本>
text = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<\2|\1>', text)
# 转换删除线: ~~文本~~ → ~文本~
text = re.sub(r'~~(.+?)~~', r'~\1~', text)
# 转换粗体: **文本** → *文本*（必须在删除线之后）
text = re.sub(r'\*\*([^*]+)\*\*', r'*\1*', text)
# 清理多余空行
text = re.sub(r'\n{3,}', '\n\n', text)
return text.strip()
def _markdown_to_simple_html(text: str) -> str:
html = text
# 转义
html = html.replace('&', '&')
html = html.replace('<', '<')
html = html.replace('>', '>')
# 链接
html = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2">\1</a>', html)
# 标题 ### → <h3>
html = re.sub(r'^### (.+)$', r'<h3>\1</h3>', html, flags=re.MULTILINE)
html = re.sub(r'^## (.+)$', r'<h2>\1</h2>', html, flags=re.MULTILINE)
html = re.sub(r'^# (.+)$', r'<h1>\1</h1>', html, flags=re.MULTILINE)
# 粗体
html = re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', html)
# 斜体
html = re.sub(r'\*(.+?)\*', r'<em>\1</em>', html)
# 删除线
html = re.sub(r'~~(.+?)~~', r'<del>\1</del>', html)
# 行内代码
html = re.sub(r'`(.+?)`', r'<code>\1</code>', html)
# 分割线
html = re.sub(r'^[\-\*]{3,}\s*$', '<hr>', html, flags=re.MULTILINE)
# 换行
html = html.replace('\n', '<br>\n')
return f"""<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>TrendRadar 通知</title>
<style>body{{font-family:sans-serif;padding:20px;max-width:800px;margin:0 auto}}
a{{color:#1a73e8}}h1,h2,h3{{color:#333}}hr{{border:none;border-top:1px solid #ddd;margin:16px 0}}
code{{background:#f5f5f5;padding:2px 6px;border-radius:3px}}</style>
</head><body>{html}</body></html>"""
# ==================== 各渠道发送器 ====================
def _send_feishu(webhook_url: str, content: str, title: str) -> Dict:
payload = {
"msg_type": "text",
"content": {
"text": content,
},
}
try:
resp = requests.post(webhook_url, json=payload, timeout=30)
data = resp.json()
ok = resp.status_code == 200 and (data.get("code") == 0 or data.get("StatusCode") == 0)
detail = ""
if not ok:
detail = data.get("msg") or data.get("StatusMessage", "")
return {"success": ok, "detail": detail}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_dingtalk(webhook_url: str, content: str, title: str) -> Dict:
payload = {
"msgtype": "markdown",
"markdown": {"title": title, "text": content}
}
try:
resp = requests.post(webhook_url, json=payload, timeout=30)
data = resp.json()
ok = resp.status_code == 200 and data.get("errcode") == 0
return {"success": ok, "detail": data.get("errmsg", "") if not ok else ""}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_wework(webhook_url: str, content: str, title: str, msg_type: str = "markdown") -> Dict:
if msg_type == "text":
payload = {"msgtype": "text", "text": {"content": strip_markdown(content)}}
else:
payload = {"msgtype": "markdown", "markdown": {"content": content}}
try:
resp = requests.post(webhook_url, json=payload, timeout=30)
data = resp.json()
ok = resp.status_code == 200 and data.get("errcode") == 0
return {"success": ok, "detail": data.get("errmsg", "") if not ok else ""}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_telegram(bot_token: str, chat_id: str, content: str, title: str) -> Dict:
url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
payload = {
"chat_id": chat_id,
"text": content,
"parse_mode": "HTML",
"disable_web_page_preview": True,
}
try:
resp = requests.post(url, json=payload, timeout=30)
data = resp.json()
ok = resp.status_code == 200 and data.get("ok")
return {"success": ok, "detail": data.get("description", "") if not ok else ""}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_email(
from_email: str, password: str, to_email: str,
message: str, title: str,
smtp_server: str = "", smtp_port: str = ""
) -> Dict:
try:
domain = from_email.split("@")[-1].lower()
html_content = _markdown_to_simple_html(message)
# SMTP 配置
if smtp_server and smtp_port:
server_host = smtp_server
port = int(smtp_port)
use_tls = port != 465
elif domain in SMTP_CONFIGS:
cfg = SMTP_CONFIGS[domain]
server_host = cfg["server"]
port = cfg["port"]
use_tls = cfg["encryption"] == "TLS"
else:
server_host = f"smtp.{domain}"
port = 587
use_tls = True
msg = MIMEMultipart("alternative")
msg["From"] = formataddr(("TrendRadar", from_email))
recipients = [addr.strip() for addr in to_email.split(",")]
msg["To"] = ", ".join(recipients)
now = datetime.now()
msg["Subject"] = Header(f"{title} - {now.strftime('%m月%d日 %H:%M')}", "utf-8")
msg["MIME-Version"] = "1.0"
msg["Date"] = formatdate(localtime=True)
msg["Message-ID"] = make_msgid()
# 纯文本备选
msg.attach(MIMEText(strip_markdown(message), "plain", "utf-8"))
# HTML 主体
msg.attach(MIMEText(html_content, "html", "utf-8"))
if use_tls:
server = smtplib.SMTP(server_host, port, timeout=30)
server.ehlo()
server.starttls()
server.ehlo()
else:
server = smtplib.SMTP_SSL(server_host, port, timeout=30)
server.ehlo()
server.login(from_email, password)
server.send_message(msg)
server.quit()
return {"success": True, "detail": ""}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_ntfy(server_url: str, topic: str, content: str, title: str, token: str = "") -> Dict:
base_url = server_url.rstrip("/")
if not base_url.startswith(("http://", "https://")):
base_url = f"https://{base_url}"
url = f"{base_url}/{topic}"
headers = {
"Content-Type": "text/plain; charset=utf-8",
"Markdown": "yes",
"Title": "TrendRadar Notification", # ASCII，避免 HTTP header 编码问题
"Priority": "default",
"Tags": "news",
}
if token:
headers["Authorization"] = f"Bearer {token}"
try:
resp = requests.post(url, data=content.encode("utf-8"), headers=headers, timeout=30)
if resp.status_code == 200:
return {"success": True, "detail": ""}
elif resp.status_code == 429:
# 速率限制，等待后重试一次（与 trendradar 一致）
time.sleep(10)
retry_resp = requests.post(url, data=content.encode("utf-8"), headers=headers, timeout=30)
ok = retry_resp.status_code == 200
return {"success": ok, "detail": "" if ok else f"retry status={retry_resp.status_code}"}
elif resp.status_code == 413:
return {"success": False, "detail": f"消息过大被拒绝 ({len(content.encode('utf-8'))} bytes)"}
else:
return {"success": False, "detail": f"status={resp.status_code}"}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_bark(bark_url: str, content: str, title: str) -> Dict:
parsed = urlparse(bark_url)
device_key = parsed.path.strip('/').split('/')[0] if parsed.path else None
if not device_key:
return {"success": False, "detail": f"无法从 URL 提取 device_key: {bark_url}"}
api_endpoint = f"{parsed.scheme}://{parsed.netloc}/push"
payload = {
"title": title,
"markdown": content,
"device_key": device_key,
"sound": "default",
"group": "TrendRadar",
"action": "none",
}
try:
resp = requests.post(api_endpoint, json=payload, timeout=30)
data = resp.json()
ok = resp.status_code == 200 and data.get("code") == 200
return {"success": ok, "detail": data.get("message", "") if not ok else ""}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_slack(webhook_url: str, content: str, title: str) -> Dict:
payload = {"text": content}
try:
resp = requests.post(webhook_url, json=payload, timeout=30)
ok = resp.status_code == 200 and resp.text == "ok"
return {"success": ok, "detail": "" if ok else resp.text}
except Exception as e:
return {"success": False, "detail": str(e)}
def _send_generic_webhook(
webhook_url: str, message: str, title: str, payload_template: str = ""
) -> Dict:
try:
if payload_template:
json_content = json.dumps(message)[1:-1]
json_title = json.dumps(title)[1:-1]
payload_str = payload_template.replace("{content}", json_content).replace("{title}", json_title)
try:
payload = json.loads(payload_str)
except json.JSONDecodeError:
payload = {"title": title, "content": message}
else:
payload = {"title": title, "content": message}
resp = requests.post(
webhook_url,
headers={"Content-Type": "application/json"},
json=payload,
timeout=30,
)
ok = 200 <= resp.status_code < 300
return {"success": ok, "detail": "" if ok else f"status={resp.status_code}"}
except Exception as e:
return {"success": False, "detail": str(e)}
# ==================== 工具类 ====================
class NotificationTools:
def __init__(self, project_root: str = None):
if project_root:
self.project_root = Path(project_root)
else:
current_file = Path(__file__)
self.project_root = current_file.parent.parent.parent
def _load_merged_config(self) -> Dict[str, Any]:
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
with open(config_path, "r", encoding="utf-8") as f:
config_data = yaml.safe_load(f)
else:
config_data = {}
webhook_config = _load_webhook_config(config_data)
notification_config = _load_notification_config(config_data)
return {**webhook_config, **notification_config}
def _detect_config_source(self, env_key: str, yaml_value: str) -> str:
env_val = os.environ.get(env_key, "").strip()
if env_val:
return "env"
elif yaml_value:
return "yaml"
return ""
def get_channel_format_guide(self, channel: Optional[str] = None) -> Dict:
if channel:
if channel not in CHANNEL_FORMAT_GUIDES:
valid = list(CHANNEL_FORMAT_GUIDES.keys())
return {
"success": False,
"error": {
"code": "INVALID_CHANNEL",
"message": f"无效的渠道: {channel}",
"suggestion": f"支持的渠道: {valid}",
},
}
guide = CHANNEL_FORMAT_GUIDES[channel]
return {
"success": True,
"channel": channel,
"guide": guide,
}
else:
return {
"success": True,
"summary": f"共 {len(CHANNEL_FORMAT_GUIDES)} 个渠道的格式化策略",
"guides": CHANNEL_FORMAT_GUIDES,
}
def get_notification_channels(self) -> Dict:
try:
config = self._load_merged_config()
enabled = config.get("ENABLE_NOTIFICATION", True)
# 从 yaml 直接读取（用于判断来源）
config_path = self.project_root / "config" / "config.yaml"
yaml_channels = {}
if config_path.exists():
with open(config_path, "r", encoding="utf-8") as f:
raw = yaml.safe_load(f) or {}
yaml_channels = raw.get("notification", {}).get("channels", {})
channels = []
env_key_map = {
"FEISHU_WEBHOOK_URL": ("feishu", "webhook_url"),
"DINGTALK_WEBHOOK_URL": ("dingtalk", "webhook_url"),
"WEWORK_WEBHOOK_URL": ("wework", "webhook_url"),
"TELEGRAM_BOT_TOKEN": ("telegram", "bot_token"),
"TELEGRAM_CHAT_ID": ("telegram", "chat_id"),
"EMAIL_FROM": ("email", "from"),
"EMAIL_PASSWORD": ("email", "password"),
"EMAIL_TO": ("email", "to"),
"NTFY_SERVER_URL": ("ntfy", "server_url"),
"NTFY_TOPIC": ("ntfy", "topic"),
"BARK_URL": ("bark", "url"),
"SLACK_WEBHOOK_URL": ("slack", "webhook_url"),
"GENERIC_WEBHOOK_URL": ("generic_webhook", "webhook_url"),
}
for channel_id, required_keys in _CHANNEL_REQUIREMENTS.items():
is_configured = all(config.get(k) for k in required_keys)
# 判断来源
sources = set()
for key in required_keys:
ch_name, field = env_key_map.get(key, ("", ""))
yaml_val = yaml_channels.get(ch_name, {}).get(field, "")
src = self._detect_config_source(key, yaml_val)
if src:
sources.add(src)
channels.append({
"id": channel_id,
"name": _CHANNEL_NAMES.get(channel_id, channel_id),
"configured": is_configured,
"source": list(sources) if sources else [],
})
configured_count = sum(1 for ch in channels if ch["configured"])
return {
"success": True,
"notification_enabled": enabled,
"summary": f"{configured_count}/{len(channels)} 个渠道已配置",
"channels": channels,
}
except Exception as e:
return {
"success": False,
"error": {"code": "INTERNAL_ERROR", "message": str(e)},
}
def send_notification(
self,
message: str,
title: str = "TrendRadar 通知",
channels: Optional[List[str]] = None,
) -> Dict:
if not message or not message.strip():
return {
"success": False,
"error": {"code": "EMPTY_MESSAGE", "message": "消息内容不能为空"},
}
try:
config = self._load_merged_config()
if not config.get("ENABLE_NOTIFICATION", True):
return {
"success": False,
"error": {"code": "NOTIFICATION_DISABLED", "message": "通知功能已禁用（notification.enabled = false）"},
}
# 确定目标渠道
all_channel_ids = list(_CHANNEL_REQUIREMENTS.keys())
if channels:
# 验证渠道名称
invalid = [ch for ch in channels if ch not in all_channel_ids]
if invalid:
raise InvalidParameterError(
f"无效的渠道: {invalid}",
suggestion=f"支持的渠道: {all_channel_ids}"
)
target_channels = channels
else:
# 发送到所有已配置渠道
target_channels = [
ch_id for ch_id, keys in _CHANNEL_REQUIREMENTS.items()
if all(config.get(k) for k in keys)
]
if not target_channels:
return {
"success": False,
"error": {
"code": "NO_CHANNELS",
"message": "没有已配置的目标渠道",
"suggestion": "请在 config.yaml 或 .env 中配置至少一个通知渠道",
},
}
# 逐渠道发送
results = {}
for ch_id in target_channels:
required_keys = _CHANNEL_REQUIREMENTS[ch_id]
if not all(config.get(k) for k in required_keys):
results[ch_id] = {"success": False, "detail": "渠道未配置"}
continue
result = self._dispatch_to_channel(ch_id, config, message, title)
results[ch_id] = result
success_count = sum(1 for r in results.values() if r["success"])
total = len(results)
return {
"success": success_count > 0,
"summary": f"{success_count}/{total} 个渠道发送成功",
"results": {
ch_id: {
"name": _CHANNEL_NAMES.get(ch_id, ch_id),
**r,
}
for ch_id, r in results.items()
},
}
except MCPError as e:
return {"success": False, "error": e.to_dict()}
except Exception as e:
return {
"success": False,
"error": {"code": "INTERNAL_ERROR", "message": str(e)},
}
def _dispatch_to_channel(
self, channel_id: str, config: Dict, message: str, title: str
) -> Dict:
# 从 config 读取批次配置（与 trendradar 一致）
batch_sizes = self._get_batch_sizes()
batch_interval = self._get_batch_interval()
# Email 无字节限制，不走分批管线
if channel_id == "email":
return _send_email(
config["EMAIL_FROM"],
config["EMAIL_PASSWORD"],
config["EMAIL_TO"],
message, title,
config.get("EMAIL_SMTP_SERVER", ""),
config.get("EMAIL_SMTP_PORT", ""),
)
# 统一分批管线：格式适配 → 字节分割 → 添加批次头部 → (可选)反序
batches = _prepare_batches(message, channel_id, batch_sizes)
# 按渠道路由发送
if channel_id == "feishu":
return self._send_batched_multi_account(
config["FEISHU_WEBHOOK_URL"], batches, channel_id,
lambda url, content: _send_feishu(url, content, title),
batch_interval,
)
elif channel_id == "dingtalk":
return self._send_batched_multi_account(
config["DINGTALK_WEBHOOK_URL"], batches, channel_id,
lambda url, content: _send_dingtalk(url, content, title),
batch_interval,
)
elif channel_id == "wework":
msg_type = config.get("WEWORK_MSG_TYPE", "markdown")
return self._send_batched_multi_account(
config["WEWORK_WEBHOOK_URL"], batches, channel_id,
lambda url, content: _send_wework(url, content, title, msg_type),
batch_interval,
)
elif channel_id == "telegram":
return self._send_batched_telegram(
config, batches, title, batch_interval,
)
elif channel_id == "ntfy":
return self._send_batched_ntfy(
config, batches, title, batch_interval,
)
elif channel_id == "bark":
return self._send_batched_multi_account(
config["BARK_URL"], batches, channel_id,
lambda url, content: _send_bark(url, content, title),
batch_interval,
)
elif channel_id == "slack":
return self._send_batched_multi_account(
config["SLACK_WEBHOOK_URL"], batches, channel_id,
lambda url, content: _send_slack(url, content, title),
batch_interval,
)
elif channel_id == "generic_webhook":
template = config.get("GENERIC_WEBHOOK_TEMPLATE", "")
return self._send_batched_multi_account(
config["GENERIC_WEBHOOK_URL"], batches, channel_id,
lambda url, content: _send_generic_webhook(url, content, title, template),
batch_interval,
)
else:
return {"success": False, "detail": f"未知渠道: {channel_id}"}
def _get_batch_sizes(self) -> Dict:
try:
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
with open(config_path, "r", encoding="utf-8") as f:
raw = yaml.safe_load(f) or {}
advanced = raw.get("advanced", {})
cfg_sizes = advanced.get("batch_size", {})
# 从 config 构建渠道映射
sizes = dict(_CHANNEL_BATCH_SIZES_DEFAULT)
default_size = cfg_sizes.get("default", 4000)
for ch_id in sizes:
if ch_id in cfg_sizes:
sizes[ch_id] = cfg_sizes[ch_id]
elif ch_id not in ("email", "ntfy") and sizes[ch_id] == 4000:
# 使用 config 中的 default
sizes[ch_id] = default_size
return sizes
except Exception:
pass
return dict(_CHANNEL_BATCH_SIZES_DEFAULT)
def _get_batch_interval(self) -> float:
try:
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
with open(config_path, "r", encoding="utf-8") as f:
raw = yaml.safe_load(f) or {}
return float(raw.get("advanced", {}).get("batch_send_interval", _BATCH_INTERVAL_DEFAULT))
except Exception:
pass
return _BATCH_INTERVAL_DEFAULT
def _send_batched_multi_account(
self, urls_str: str, batches: List[str], channel_id: str, send_func,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
urls = [u.strip() for u in urls_str.split(";") if u.strip()]
if not urls:
return {"success": False, "detail": "URL 为空"}
any_ok = False
details = []
for url in urls:
for i, batch in enumerate(batches):
r = send_func(url, batch)
if r["success"]:
any_ok = True
elif r["detail"]:
details.append(r["detail"])
# 批次间间隔
if i < len(batches) - 1:
time.sleep(batch_interval)
return {
"success": any_ok,
"detail": "; ".join(details) if details else "",
"batches": len(batches),
}
def _send_batched_telegram(
self, config: Dict, batches: List[str], title: str,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
tokens = config["TELEGRAM_BOT_TOKEN"].split(";")
chat_ids = config["TELEGRAM_CHAT_ID"].split(";")
if len(tokens) != len(chat_ids):
return {"success": False, "detail": "bot_token 和 chat_id 数量不一致"}
any_ok = False
details = []
for token, cid in zip(tokens, chat_ids):
token, cid = token.strip(), cid.strip()
if not (token and cid):
continue
for i, batch in enumerate(batches):
r = _send_telegram(token, cid, batch, title)
if r["success"]:
any_ok = True
elif r["detail"]:
details.append(r["detail"])
if i < len(batches) - 1:
time.sleep(batch_interval)
return {
"success": any_ok,
"detail": "; ".join(details) if details else "",
"batches": len(batches),
}
def _send_batched_ntfy(
self, config: Dict, batches: List[str], title: str,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
servers = config["NTFY_SERVER_URL"].split(";")
topics = config["NTFY_TOPIC"].split(";")
tokens_str = config.get("NTFY_TOKEN", "")
tokens = tokens_str.split(";") if tokens_str else [""]
if len(servers) != len(topics):
return {"success": False, "detail": "server_url 和 topic 数量不一致"}
any_ok = False
details = []
for i, (srv, topic) in enumerate(zip(servers, topics)):
srv, topic = srv.strip(), topic.strip()
tk = tokens[i].strip() if i < len(tokens) else ""
if not (srv and topic):
continue
# ntfy.sh 公共服务器用 2s 间隔（与 trendradar 一致）
interval = 2.0 if "ntfy.sh" in srv else batch_interval
for j, batch in enumerate(batches):
r = _send_ntfy(srv, topic, batch, title, tk)
if r["success"]:
any_ok = True
elif r["detail"]:
details.append(r["detail"])
if j < len(batches) - 1:
time.sleep(interval)
return {
"success": any_ok,
"detail": "; ".join(details) if details else "",
"batches": len(batches),
} | --- +++ @@ -1,4 +1,10 @@ # coding=utf-8
+"""
+通知推送工具
+
+支持向已配置的通知渠道发送消息，自动检测 config.yaml 和 .env 中的渠道配置。
+接受 markdown 格式内容，内部按各渠道要求自动转换格式后发送。
+"""
import json
import os
@@ -89,6 +95,20 @@
def _split_text_into_batches(text: str, max_bytes: int) -> List[str]:
+ """将文本按字节限制分批，优先在段落边界（双换行）切割
+
+ 分割策略（参考 trendradar splitter.py 的原子性保证）：
+ 1. 优先按段落（双换行 \\n\\n）拆分
+ 2. 段落仍超限时，按单行（\\n）拆分
+ 3. 单行仍超限时，用 _truncate_to_bytes 安全截断
+
+ Args:
+ text: 已转换为目标渠道格式的文本
+ max_bytes: 单批最大字节数（已扣除批次头部预留）
+
+ Returns:
+ 分批后的文本列表
+ """
if max_bytes <= 0 or len(text.encode("utf-8")) <= max_bytes:
return [text]
@@ -141,6 +161,18 @@
def _format_for_channel(message: str, channel_id: str) -> str:
+ """将通用 Markdown 适配并转换为目标渠道格式
+
+ 统一入口：先适配（剥离不支持的语法），再转换（Markdown→HTML/mrkdwn 等）。
+ 返回的文本可以直接用于字节分割和发送。
+
+ Args:
+ message: 原始 Markdown 格式文本
+ channel_id: 目标渠道 ID
+
+ Returns:
+ 目标渠道格式的文本
+ """
if channel_id == "feishu":
return _adapt_markdown_for_feishu(message)
elif channel_id == "dingtalk":
@@ -161,6 +193,16 @@
def _prepare_batches(message: str, channel_id: str, batch_sizes: Dict = None) -> List[str]:
+ """完整的分批管线：格式适配 → 字节分割 → 添加批次头部
+
+ Args:
+ message: 原始 Markdown 格式文本
+ channel_id: 目标渠道 ID
+ batch_sizes: 各渠道批次大小字典（来自 config.yaml），None 使用默认值
+
+ Returns:
+ 准备好的批次列表（已添加头部，已处理反序）
+ """
sizes = batch_sizes or _CHANNEL_BATCH_SIZES_DEFAULT
max_bytes = sizes.get(channel_id, sizes.get("default", 4000))
if max_bytes <= 0:
@@ -439,6 +481,11 @@ # ==================== 渠道 Markdown 适配 ====================
def _adapt_markdown_for_feishu(text: str) -> str:
+ """将通用 Markdown 适配为飞书卡片 Markdown 格式
+
+ 飞书卡片支持：**粗体**, [链接](url), <font color='...'>, ---
+ 不支持：# 标题, > 引用块
+ """
# 将 # 标题转换为粗体（飞书卡片不渲染标题语法）
text = re.sub(r'^#{1,6}\s+(.+)$', r'**\1**', text, flags=re.MULTILINE)
# 去除引用语法前缀（飞书不支持）
@@ -449,6 +496,11 @@
def _adapt_markdown_for_dingtalk(text: str) -> str:
+ """将通用 Markdown 适配为钉钉 Markdown 格式
+
+ 钉钉支持：### #### 标题, **粗体**, [链接](url), > 引用, ---
+ 不支持：# ## 标题, <font> 彩色文本, ~~删除线~~
+ """
# 去除 <font> 标签（钉钉不支持，保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 和 ## 标题降级为 ### （钉钉仅支持 ### 和 ####）
@@ -462,6 +514,11 @@
def _adapt_markdown_for_wework(text: str) -> str:
+ """将通用 Markdown 适配为企业微信 Markdown 格式
+
+ 企业微信支持：**粗体**, [链接](url), > 引用（有限）
+ 不支持：# 标题, ---, <font>, ~~删除线~~, 有序列表
+ """
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体（企业微信不渲染标题语法）
@@ -476,6 +533,11 @@
def _adapt_markdown_for_ntfy(text: str) -> str:
+ """将通用 Markdown 适配为 ntfy 格式
+
+ ntfy 支持：**粗体**, *斜体*, [链接](url), > 引用, `代码`
+ 不可靠：# 标题, ---, <font>
+ """
# 去除 <font> 标签（ntfy 不支持）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 清理多余空行
@@ -484,6 +546,11 @@
def _adapt_markdown_for_bark(text: str) -> str:
+ """将通用 Markdown 适配为 Bark 格式（iOS 推送）
+
+ Bark 支持：**粗体**, [链接](url), 基础文本
+ 不支持：# 标题, <font>, ---, > 引用, 复杂嵌套
+ """
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体
@@ -502,6 +569,11 @@ # ==================== 格式转换 ====================
def _markdown_to_telegram_html(text: str) -> str:
+ """
+ 将 markdown 转换为 Telegram 支持的 HTML 格式
+
+ Telegram 支持的标签：<b>, <i>, <s>, <code>, <a href="url">text</a>, <blockquote>
+ """
# 预处理：去除 <font> 标签（Telegram 不支持，保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
@@ -577,6 +649,14 @@
def _convert_markdown_to_slack(text: str) -> str:
+ """将 Markdown 转换为 Slack mrkdwn 格式（增强版）
+
+ Slack mrkdwn 与标准 Markdown 差异：
+ - 粗体: *text* (非 **text**)
+ - 删除线: ~text~ (非 ~~text~~)
+ - 链接: <url|text> (非 [text](url))
+ - 不支持标题语法
+ """
# 去除 <font> 标签（保留内容）
text = re.sub(r'<font[^>]*>(.+?)</font>', r'\1', text)
# 将 # 标题转换为粗体（Slack 无标题样式）
@@ -595,6 +675,9 @@
def _markdown_to_simple_html(text: str) -> str:
+ """
+ 将 markdown 转换为简单 HTML（用于 Email）
+ """
html = text
# 转义
@@ -639,6 +722,10 @@ # ==================== 各渠道发送器 ====================
def _send_feishu(webhook_url: str, content: str, title: str) -> Dict:
+ """飞书发送（纯文本消息，与 trendradar send_to_feishu 一致）
+
+ 飞书 webhook 使用 msg_type: "text"，所有信息整合到 content.text 中。
+ """
payload = {
"msg_type": "text",
"content": {
@@ -658,6 +745,7 @@
def _send_dingtalk(webhook_url: str, content: str, title: str) -> Dict:
+ """钉钉发送（接收已适配的 Markdown）"""
payload = {
"msgtype": "markdown",
"markdown": {"title": title, "text": content}
@@ -672,6 +760,7 @@
def _send_wework(webhook_url: str, content: str, title: str, msg_type: str = "markdown") -> Dict:
+ """企业微信发送（接收已适配的 Markdown，text 模式自动剥离格式）"""
if msg_type == "text":
payload = {"msgtype": "text", "text": {"content": strip_markdown(content)}}
else:
@@ -687,6 +776,7 @@
def _send_telegram(bot_token: str, chat_id: str, content: str, title: str) -> Dict:
+ """Telegram 发送（接收已转换的 HTML）"""
url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
payload = {
"chat_id": chat_id,
@@ -708,6 +798,7 @@ message: str, title: str,
smtp_server: str = "", smtp_port: str = ""
) -> Dict:
+ """邮件发送（HTML 格式）"""
try:
domain = from_email.split("@")[-1].lower()
html_content = _markdown_to_simple_html(message)
@@ -763,6 +854,11 @@
def _send_ntfy(server_url: str, topic: str, content: str, title: str, token: str = "") -> Dict:
+ """ntfy 发送（接收已适配的 Markdown，与 trendradar send_to_ntfy 一致）
+
+ 注意：Title 使用 ASCII 字符避免 HTTP header 编码问题。
+ 支持 429 速率限制重试。
+ """
base_url = server_url.rstrip("/")
if not base_url.startswith(("http://", "https://")):
base_url = f"https://{base_url}"
@@ -797,6 +893,7 @@
def _send_bark(bark_url: str, content: str, title: str) -> Dict:
+ """Bark 发送（接收已适配的 Markdown，iOS 推送）"""
parsed = urlparse(bark_url)
device_key = parsed.path.strip('/').split('/')[0] if parsed.path else None
if not device_key:
@@ -822,6 +919,7 @@
def _send_slack(webhook_url: str, content: str, title: str) -> Dict:
+ """Slack 发送（接收已转换的 mrkdwn）"""
payload = {"text": content}
try:
@@ -835,6 +933,7 @@ def _send_generic_webhook(
webhook_url: str, message: str, title: str, payload_template: str = ""
) -> Dict:
+ """通用 Webhook 发送（Markdown 格式，支持自定义模板）"""
try:
if payload_template:
json_content = json.dumps(message)[1:-1]
@@ -862,6 +961,7 @@ # ==================== 工具类 ====================
class NotificationTools:
+ """通知推送工具类"""
def __init__(self, project_root: str = None):
if project_root:
@@ -871,6 +971,12 @@ self.project_root = current_file.parent.parent.parent
def _load_merged_config(self) -> Dict[str, Any]:
+ """
+ 加载合并后的通知配置（config.yaml + .env）
+
+ Returns:
+ 包含 webhook 配置和通知参数的合并字典
+ """
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
with open(config_path, "r", encoding="utf-8") as f:
@@ -883,6 +989,7 @@ return {**webhook_config, **notification_config}
def _detect_config_source(self, env_key: str, yaml_value: str) -> str:
+ """检测配置项来源：env / yaml / 未配置"""
env_val = os.environ.get(env_key, "").strip()
if env_val:
return "env"
@@ -891,6 +998,18 @@ return ""
def get_channel_format_guide(self, channel: Optional[str] = None) -> Dict:
+ """
+ 获取渠道格式化策略指南
+
+ 返回各渠道支持的 Markdown 特性、限制和最佳格式化提示词，
+ 供 LLM 在生成推送内容时参考，确保内容样式贴合目标渠道。
+
+ Args:
+ channel: 指定渠道 ID，None 返回所有渠道的策略
+
+ Returns:
+ 格式化策略字典
+ """
if channel:
if channel not in CHANNEL_FORMAT_GUIDES:
valid = list(CHANNEL_FORMAT_GUIDES.keys())
@@ -916,6 +1035,14 @@ }
def get_notification_channels(self) -> Dict:
+ """
+ 获取所有通知渠道的配置状态
+
+ 检测 config.yaml 和 .env 环境变量，返回每个渠道是否已配置。
+
+ Returns:
+ 渠道状态字典
+ """
try:
config = self._load_merged_config()
enabled = config.get("ENABLE_NOTIFICATION", True)
@@ -984,6 +1111,20 @@ title: str = "TrendRadar 通知",
channels: Optional[List[str]] = None,
) -> Dict:
+ """
+ 向已配置的通知渠道发送消息
+
+ 接受 markdown 格式内容，内部自动转换为各渠道要求的格式。
+
+ Args:
+ message: markdown 格式的消息内容
+ title: 消息标题
+ channels: 指定发送的渠道列表，None 表示发送到所有已配置渠道
+ 可选值: feishu, dingtalk, wework, telegram, email, ntfy, bark, slack, generic_webhook
+
+ Returns:
+ 发送结果字典
+ """
if not message or not message.strip():
return {
"success": False,
@@ -1064,6 +1205,10 @@ def _dispatch_to_channel(
self, channel_id: str, config: Dict, message: str, title: str
) -> Dict:
+ """分发消息到指定渠道（格式适配 → 字节分批 → 多账号 × 逐批发送）
+
+ 从 config.yaml → advanced.batch_size / batch_send_interval 读取配置。
+ """
# 从 config 读取批次配置（与 trendradar 一致）
batch_sizes = self._get_batch_sizes()
batch_interval = self._get_batch_interval()
@@ -1133,6 +1278,7 @@ return {"success": False, "detail": f"未知渠道: {channel_id}"}
def _get_batch_sizes(self) -> Dict:
+ """从 config.yaml 读取 advanced.batch_size，合并到默认值"""
try:
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
@@ -1155,6 +1301,7 @@ return dict(_CHANNEL_BATCH_SIZES_DEFAULT)
def _get_batch_interval(self) -> float:
+ """从 config.yaml 读取 advanced.batch_send_interval"""
try:
config_path = self.project_root / "config" / "config.yaml"
if config_path.exists():
@@ -1169,6 +1316,7 @@ self, urls_str: str, batches: List[str], channel_id: str, send_func,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
+ """多账号 × 逐批发送（; 分隔的 URL）"""
urls = [u.strip() for u in urls_str.split(";") if u.strip()]
if not urls:
return {"success": False, "detail": "URL 为空"}
@@ -1196,6 +1344,7 @@ self, config: Dict, batches: List[str], title: str,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
+ """Telegram 多账号 × 逐批发送（token/chat_id 配对）"""
tokens = config["TELEGRAM_BOT_TOKEN"].split(";")
chat_ids = config["TELEGRAM_CHAT_ID"].split(";")
if len(tokens) != len(chat_ids):
@@ -1226,6 +1375,7 @@ self, config: Dict, batches: List[str], title: str,
batch_interval: float = _BATCH_INTERVAL_DEFAULT,
) -> Dict:
+ """ntfy 多账号 × 逐批发送（server/topic/token 配对，含速率限制处理）"""
servers = config["NTFY_SERVER_URL"].split(";")
topics = config["NTFY_TOPIC"].split(";")
tokens_str = config.get("NTFY_TOKEN", "")
@@ -1255,4 +1405,4 @@ "success": any_ok,
"detail": "; ".join(details) if details else "",
"batches": len(batches),
- }+ }
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/tools/notification.py |
Add docstrings to my Python code | from __future__ import annotations
"""Growth Agent
Implements a growth-focused valuation methodology.
"""
import json
import statistics
from langchain_core.messages import HumanMessage
from src.graph.state import AgentState, show_agent_reasoning
from src.utils.progress import progress
from src.utils.api_key import get_api_key_from_state
from src.tools.api import (
get_financial_metrics,
get_insider_trades,
)
def growth_analyst_agent(state: AgentState, agent_id: str = "growth_analyst_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
growth_analysis: dict[str, dict] = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial data")
# --- Historical financial metrics ---
financial_metrics = get_financial_metrics(
ticker=ticker,
end_date=end_date,
period="ttm",
limit=12, # 3 years of ttm data
api_key=api_key,
)
if not financial_metrics or len(financial_metrics) < 4:
progress.update_status(agent_id, ticker, "Failed: Not enough financial metrics")
continue
most_recent_metrics = financial_metrics[0]
# --- Insider Trades ---
insider_trades = get_insider_trades(
ticker=ticker,
end_date=end_date,
limit=1000,
api_key=api_key
)
# ------------------------------------------------------------------
# Tool Implementation
# ------------------------------------------------------------------
# 1. Historical Growth Analysis
growth_trends = analyze_growth_trends(financial_metrics)
# 2. Growth-Oriented Valuation
valuation_metrics = analyze_valuation(most_recent_metrics)
# 3. Margin Expansion Monitor
margin_trends = analyze_margin_trends(financial_metrics)
# 4. Insider Conviction Tracker
insider_conviction = analyze_insider_conviction(insider_trades)
# 5. Financial Health Check
financial_health = check_financial_health(most_recent_metrics)
# ------------------------------------------------------------------
# Aggregate & signal
# ------------------------------------------------------------------
scores = {
"growth": growth_trends['score'],
"valuation": valuation_metrics['score'],
"margins": margin_trends['score'],
"insider": insider_conviction['score'],
"health": financial_health['score']
}
weights = {
"growth": 0.40,
"valuation": 0.25,
"margins": 0.15,
"insider": 0.10,
"health": 0.10
}
weighted_score = sum(scores[key] * weights[key] for key in scores)
if weighted_score > 0.6:
signal = "bullish"
elif weighted_score < 0.4:
signal = "bearish"
else:
signal = "neutral"
confidence = round(abs(weighted_score - 0.5) * 2 * 100)
reasoning = {
"historical_growth": growth_trends,
"growth_valuation": valuation_metrics,
"margin_expansion": margin_trends,
"insider_conviction": insider_conviction,
"financial_health": financial_health,
"final_analysis": {
"signal": signal,
"confidence": confidence,
"weighted_score": round(weighted_score, 2)
}
}
growth_analysis[ticker] = {
"signal": signal,
"confidence": confidence,
"reasoning": reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=json.dumps(reasoning, indent=4))
# ---- Emit message (for LLM tool chain) ----
msg = HumanMessage(content=json.dumps(growth_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(growth_analysis, "Growth Analysis Agent")
# Add the signal to the analyst_signals list
state["data"]["analyst_signals"][agent_id] = growth_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [msg], "data": data}
#############################
# Helper Functions
#############################
def _calculate_trend(data: list[float | None]) -> float:
clean_data = [d for d in data if d is not None]
if len(clean_data) < 2:
return 0.0
y = clean_data
x = list(range(len(y)))
try:
# Simple linear regression
sum_x = sum(x)
sum_y = sum(y)
sum_xy = sum(i * j for i, j in zip(x, y))
sum_x2 = sum(i**2 for i in x)
n = len(y)
slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x**2)
return slope
except ZeroDivisionError:
return 0.0
def analyze_growth_trends(metrics: list) -> dict:
rev_growth = [m.revenue_growth for m in metrics]
eps_growth = [m.earnings_per_share_growth for m in metrics]
fcf_growth = [m.free_cash_flow_growth for m in metrics]
rev_trend = _calculate_trend(rev_growth)
eps_trend = _calculate_trend(eps_growth)
fcf_trend = _calculate_trend(fcf_growth)
# Score based on recent growth and trend
score = 0
# Revenue
if rev_growth[0] is not None:
if rev_growth[0] > 0.20:
score += 0.4
elif rev_growth[0] > 0.10:
score += 0.2
if rev_trend > 0:
score += 0.1 # Accelerating
# EPS
if eps_growth[0] is not None:
if eps_growth[0] > 0.20:
score += 0.25
elif eps_growth[0] > 0.10:
score += 0.1
if eps_trend > 0:
score += 0.05
# FCF
if fcf_growth[0] is not None:
if fcf_growth[0] > 0.15:
score += 0.1
score = min(score, 1.0)
return {
"score": score,
"revenue_growth": rev_growth[0],
"revenue_trend": rev_trend,
"eps_growth": eps_growth[0],
"eps_trend": eps_trend,
"fcf_growth": fcf_growth[0],
"fcf_trend": fcf_trend
}
def analyze_valuation(metrics) -> dict:
peg_ratio = metrics.peg_ratio
ps_ratio = metrics.price_to_sales_ratio
score = 0
# PEG Ratio
if peg_ratio is not None:
if peg_ratio < 1.0:
score += 0.5
elif peg_ratio < 2.0:
score += 0.25
# Price to Sales Ratio
if ps_ratio is not None:
if ps_ratio < 2.0:
score += 0.5
elif ps_ratio < 5.0:
score += 0.25
score = min(score, 1.0)
return {
"score": score,
"peg_ratio": peg_ratio,
"price_to_sales_ratio": ps_ratio
}
def analyze_margin_trends(metrics: list) -> dict:
gross_margins = [m.gross_margin for m in metrics]
operating_margins = [m.operating_margin for m in metrics]
net_margins = [m.net_margin for m in metrics]
gm_trend = _calculate_trend(gross_margins)
om_trend = _calculate_trend(operating_margins)
nm_trend = _calculate_trend(net_margins)
score = 0
# Gross Margin
if gross_margins[0] is not None:
if gross_margins[0] > 0.5: # Healthy margin
score += 0.2
if gm_trend > 0: # Expanding
score += 0.2
# Operating Margin
if operating_margins[0] is not None:
if operating_margins[0] > 0.15: # Healthy margin
score += 0.2
if om_trend > 0: # Expanding
score += 0.2
# Net Margin Trend
if nm_trend > 0:
score += 0.2
score = min(score, 1.0)
return {
"score": score,
"gross_margin": gross_margins[0],
"gross_margin_trend": gm_trend,
"operating_margin": operating_margins[0],
"operating_margin_trend": om_trend,
"net_margin": net_margins[0],
"net_margin_trend": nm_trend
}
def analyze_insider_conviction(trades: list) -> dict:
buys = sum(t.transaction_value for t in trades if t.transaction_value and t.transaction_shares > 0)
sells = sum(abs(t.transaction_value) for t in trades if t.transaction_value and t.transaction_shares < 0)
if (buys + sells) == 0:
net_flow_ratio = 0
else:
net_flow_ratio = (buys - sells) / (buys + sells)
score = 0
if net_flow_ratio > 0.5:
score = 1.0
elif net_flow_ratio > 0.1:
score = 0.7
elif net_flow_ratio > -0.1:
score = 0.5 # Neutral
else:
score = 0.2
return {
"score": score,
"net_flow_ratio": net_flow_ratio,
"buys": buys,
"sells": sells
}
def check_financial_health(metrics) -> dict:
debt_to_equity = metrics.debt_to_equity
current_ratio = metrics.current_ratio
score = 1.0
# Debt to Equity
if debt_to_equity is not None:
if debt_to_equity > 1.5:
score -= 0.5
elif debt_to_equity > 0.8:
score -= 0.2
# Current Ratio
if current_ratio is not None:
if current_ratio < 1.0:
score -= 0.5
elif current_ratio < 1.5:
score -= 0.2
score = max(score, 0.0)
return {
"score": score,
"debt_to_equity": debt_to_equity,
"current_ratio": current_ratio
} | --- +++ @@ -17,6 +17,7 @@ )
def growth_analyst_agent(state: AgentState, agent_id: str = "growth_analyst_agent"):
+ """Run growth analysis across tickers and write signals back to `state`."""
data = state["data"]
end_date = data["end_date"]
@@ -135,6 +136,7 @@ #############################
def _calculate_trend(data: list[float | None]) -> float:
+ """Calculates the slope of the trend line for the given data."""
clean_data = [d for d in data if d is not None]
if len(clean_data) < 2:
return 0.0
@@ -156,6 +158,7 @@ return 0.0
def analyze_growth_trends(metrics: list) -> dict:
+ """Analyzes historical growth trends."""
rev_growth = [m.revenue_growth for m in metrics]
eps_growth = [m.earnings_per_share_growth for m in metrics]
@@ -204,6 +207,7 @@ }
def analyze_valuation(metrics) -> dict:
+ """Analyzes valuation from a growth perspective."""
peg_ratio = metrics.peg_ratio
ps_ratio = metrics.price_to_sales_ratio
@@ -233,6 +237,7 @@ }
def analyze_margin_trends(metrics: list) -> dict:
+ """Analyzes historical margin trends."""
gross_margins = [m.gross_margin for m in metrics]
operating_margins = [m.operating_margin for m in metrics]
@@ -275,6 +280,7 @@ }
def analyze_insider_conviction(trades: list) -> dict:
+ """Analyzes insider trading activity."""
buys = sum(t.transaction_value for t in trades if t.transaction_value and t.transaction_shares > 0)
sells = sum(abs(t.transaction_value) for t in trades if t.transaction_value and t.transaction_shares < 0)
@@ -302,6 +308,7 @@ }
def check_financial_health(metrics) -> dict:
+ """Checks the company's financial health."""
debt_to_equity = metrics.debt_to_equity
current_ratio = metrics.current_ratio
@@ -328,4 +335,4 @@ "score": score,
"debt_to_equity": debt_to_equity,
"current_ratio": current_ratio
- }+ }
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/growth_agent.py |
Generate missing documentation strings |
from typing import Dict, List, Optional, Union
from ..services.data_service import DataService
from ..utils.validators import (
validate_platforms,
validate_limit,
validate_keyword,
validate_date_range,
validate_top_n,
validate_mode,
validate_date_query,
normalize_date_range
)
from ..utils.errors import MCPError
class DataQueryTools:
def __init__(self, project_root: str = None):
self.data_service = DataService(project_root)
def get_latest_news(
self,
platforms: Optional[List[str]] = None,
limit: Optional[int] = None,
include_url: bool = False
) -> Dict:
try:
# 参数验证
platforms = validate_platforms(platforms)
limit = validate_limit(limit, default=50)
# 获取数据
news_list = self.data_service.get_latest_news(
platforms=platforms,
limit=limit,
include_url=include_url
)
return {
"success": True,
"summary": {
"description": "最新一批爬取的新闻数据",
"total": len(news_list),
"returned": len(news_list),
"platforms": platforms or "全部平台"
},
"data": news_list
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def search_news_by_keyword(
self,
keyword: str,
date_range: Optional[Union[Dict, str]] = None,
platforms: Optional[List[str]] = None,
limit: Optional[int] = None
) -> Dict:
try:
# 参数验证
keyword = validate_keyword(keyword)
date_range_tuple = validate_date_range(date_range)
platforms = validate_platforms(platforms)
if limit is not None:
limit = validate_limit(limit, default=100)
# 搜索数据
search_result = self.data_service.search_news_by_keyword(
keyword=keyword,
date_range=date_range_tuple,
platforms=platforms,
limit=limit
)
return {
**search_result,
"success": True
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def get_trending_topics(
self,
top_n: Optional[int] = None,
mode: Optional[str] = None,
extract_mode: Optional[str] = None
) -> Dict:
try:
# 参数验证
top_n = validate_top_n(top_n, default=10)
valid_modes = ["daily", "current"]
mode = validate_mode(mode, valid_modes, default="current")
# 验证 extract_mode
if extract_mode is None:
extract_mode = "keywords"
elif extract_mode not in ["keywords", "auto_extract"]:
return {
"success": False,
"error": {
"code": "INVALID_PARAMETER",
"message": f"不支持的提取模式: {extract_mode}",
"suggestion": "支持的模式: keywords, auto_extract"
}
}
# 获取趋势话题
trending_result = self.data_service.get_trending_topics(
top_n=top_n,
mode=mode,
extract_mode=extract_mode
)
return {
**trending_result,
"success": True
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def get_news_by_date(
self,
date_range: Optional[Union[Dict[str, str], str]] = None,
platforms: Optional[List[str]] = None,
limit: Optional[int] = None,
include_url: bool = False
) -> Dict:
try:
# 参数验证 - 默认今天
if date_range is None:
date_range = "今天"
# 规范化 date_range（处理 JSON 字符串序列化问题）
date_range = normalize_date_range(date_range)
# 处理 date_range：支持字符串或对象
if isinstance(date_range, dict):
# 范围对象，取 start 日期
date_str = date_range.get('start', '今天')
else:
date_str = date_range
target_date = validate_date_query(date_str)
platforms = validate_platforms(platforms)
limit = validate_limit(limit, default=50)
# 获取数据
news_list = self.data_service.get_news_by_date(
target_date=target_date,
platforms=platforms,
limit=limit,
include_url=include_url
)
return {
"success": True,
"summary": {
"description": f"按日期查询的新闻（{target_date.strftime('%Y-%m-%d')}）",
"total": len(news_list),
"returned": len(news_list),
"date": target_date.strftime("%Y-%m-%d"),
"date_range": date_range,
"platforms": platforms or "全部平台"
},
"data": news_list
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
# ========================================
# RSS 数据查询方法
# ========================================
def get_latest_rss(
self,
feeds: Optional[List[str]] = None,
days: int = 1,
limit: Optional[int] = None,
include_summary: bool = False
) -> Dict:
try:
limit = validate_limit(limit, default=50)
rss_list = self.data_service.get_latest_rss(
feeds=feeds,
days=days,
limit=limit,
include_summary=include_summary
)
return {
"success": True,
"summary": {
"description": f"最近 {days} 天的 RSS 订阅数据" if days > 1 else "最新的 RSS 订阅数据",
"total": len(rss_list),
"returned": len(rss_list),
"days": days,
"feeds": feeds or "全部订阅源"
},
"data": rss_list
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def search_rss(
self,
keyword: str,
feeds: Optional[List[str]] = None,
days: int = 7,
limit: Optional[int] = None,
include_summary: bool = False
) -> Dict:
try:
keyword = validate_keyword(keyword)
limit = validate_limit(limit, default=50)
if days < 1 or days > 30:
days = 7
rss_list = self.data_service.search_rss(
keyword=keyword,
feeds=feeds,
days=days,
limit=limit,
include_summary=include_summary
)
return {
"success": True,
"summary": {
"description": f"RSS 搜索结果（关键词: {keyword}）",
"total": len(rss_list),
"returned": len(rss_list),
"keyword": keyword,
"feeds": feeds or "全部订阅源",
"days": days
},
"data": rss_list
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def get_rss_feeds_status(self) -> Dict:
try:
status = self.data_service.get_rss_feeds_status()
return {
**status,
"success": True
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
| --- +++ @@ -1,3 +1,8 @@+"""
+数据查询工具
+
+实现P0核心的数据查询工具。
+"""
from typing import Dict, List, Optional, Union
@@ -16,8 +21,15 @@
class DataQueryTools:
+ """数据查询工具类"""
def __init__(self, project_root: str = None):
+ """
+ 初始化数据查询工具
+
+ Args:
+ project_root: 项目根目录
+ """
self.data_service = DataService(project_root)
def get_latest_news(
@@ -26,6 +38,23 @@ limit: Optional[int] = None,
include_url: bool = False
) -> Dict:
+ """
+ 获取最新一批爬取的新闻数据
+
+ Args:
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']
+ limit: 返回条数限制，默认20
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ 新闻列表字典
+
+ Example:
+ >>> tools = DataQueryTools()
+ >>> result = tools.get_latest_news(platforms=['zhihu'], limit=10)
+ >>> print(result['total'])
+ 10
+ """
try:
# 参数验证
platforms = validate_platforms(platforms)
@@ -70,6 +99,27 @@ platforms: Optional[List[str]] = None,
limit: Optional[int] = None
) -> Dict:
+ """
+ 按关键词搜索历史新闻
+
+ Args:
+ keyword: 搜索关键词（必需）
+ date_range: 日期范围，格式: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ platforms: 平台过滤列表
+ limit: 返回条数限制（可选，默认返回所有）
+
+ Returns:
+ 搜索结果字典
+
+ Example (假设今天是 2025-11-17):
+ >>> tools = DataQueryTools()
+ >>> result = tools.search_news_by_keyword(
+ ... keyword="人工智能",
+ ... date_range={"start": "2025-11-08", "end": "2025-11-17"},
+ ... limit=50
+ ... )
+ >>> print(result['total'])
+ """
try:
# 参数验证
keyword = validate_keyword(keyword)
@@ -112,6 +162,28 @@ mode: Optional[str] = None,
extract_mode: Optional[str] = None
) -> Dict:
+ """
+ 获取热点话题统计
+
+ Args:
+ top_n: 返回TOP N话题，默认10
+ mode: 时间模式
+ - "daily": 当日累计数据统计
+ - "current": 最新一批数据统计（默认）
+ extract_mode: 提取模式
+ - "keywords": 统计预设关注词（基于 config/frequency_words.txt，默认）
+ - "auto_extract": 自动从新闻标题提取高频词
+
+ Returns:
+ 话题频率统计字典
+
+ Example:
+ >>> tools = DataQueryTools()
+ >>> # 使用预设关注词
+ >>> result = tools.get_trending_topics(top_n=5, mode="current")
+ >>> # 自动提取高频词
+ >>> result = tools.get_trending_topics(top_n=10, extract_mode="auto_extract")
+ """
try:
# 参数验证
top_n = validate_top_n(top_n, default=10)
@@ -164,6 +236,34 @@ limit: Optional[int] = None,
include_url: bool = False
) -> Dict:
+ """
+ 按日期查询新闻，支持自然语言日期
+
+ Args:
+ date_range: 日期范围（可选，默认"今天"），支持：
+ - 范围对象：{"start": "2025-01-01", "end": "2025-01-07"}
+ - 相对日期：今天、昨天、前天、3天前
+ - 单日字符串：2025-10-10
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']
+ limit: 返回条数限制，默认50
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ 新闻列表字典
+
+ Example:
+ >>> tools = DataQueryTools()
+ >>> # 不指定日期，默认查询今天
+ >>> result = tools.get_news_by_date(platforms=['zhihu'], limit=20)
+ >>> # 指定日期
+ >>> result = tools.get_news_by_date(
+ ... date_range="昨天",
+ ... platforms=['zhihu'],
+ ... limit=20
+ ... )
+ >>> print(result['total'])
+ 20
+ """
try:
# 参数验证 - 默认今天
if date_range is None:
@@ -228,6 +328,18 @@ limit: Optional[int] = None,
include_summary: bool = False
) -> Dict:
+ """
+ 获取最新的 RSS 数据（支持多日查询）
+
+ Args:
+ feeds: RSS 源 ID 列表，如 ['hacker-news', '36kr']
+ days: 获取最近 N 天的数据，默认 1（仅今天），最大 30 天
+ limit: 返回条数限制，默认50
+ include_summary: 是否包含摘要，默认False（节省token）
+
+ Returns:
+ RSS 条目列表字典
+ """
try:
limit = validate_limit(limit, default=50)
@@ -272,6 +384,19 @@ limit: Optional[int] = None,
include_summary: bool = False
) -> Dict:
+ """
+ 搜索 RSS 数据
+
+ Args:
+ keyword: 搜索关键词
+ feeds: RSS 源 ID 列表
+ days: 搜索最近 N 天的数据，默认 7 天
+ limit: 返回条数限制，默认50
+ include_summary: 是否包含摘要
+
+ Returns:
+ 匹配的 RSS 条目列表
+ """
try:
keyword = validate_keyword(keyword)
limit = validate_limit(limit, default=50)
@@ -315,6 +440,12 @@ }
def get_rss_feeds_status(self) -> Dict:
+ """
+ 获取 RSS 源状态
+
+ Returns:
+ RSS 源状态信息
+ """
try:
status = self.data_service.get_rss_feeds_status()
@@ -336,3 +467,4 @@ "message": str(e)
}
}
+
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/tools/data_query.py |
Include argument descriptions in docstrings | class Cache:
def __init__(self):
self._prices_cache: dict[str, list[dict[str, any]]] = {}
self._financial_metrics_cache: dict[str, list[dict[str, any]]] = {}
self._line_items_cache: dict[str, list[dict[str, any]]] = {}
self._insider_trades_cache: dict[str, list[dict[str, any]]] = {}
self._company_news_cache: dict[str, list[dict[str, any]]] = {}
def _merge_data(self, existing: list[dict] | None, new_data: list[dict], key_field: str) -> list[dict]:
if not existing:
return new_data
# Create a set of existing keys for O(1) lookup
existing_keys = {item[key_field] for item in existing}
# Only add items that don't exist yet
merged = existing.copy()
merged.extend([item for item in new_data if item[key_field] not in existing_keys])
return merged
def get_prices(self, ticker: str) -> list[dict[str, any]] | None:
return self._prices_cache.get(ticker)
def set_prices(self, ticker: str, data: list[dict[str, any]]):
self._prices_cache[ticker] = self._merge_data(self._prices_cache.get(ticker), data, key_field="time")
def get_financial_metrics(self, ticker: str) -> list[dict[str, any]]:
return self._financial_metrics_cache.get(ticker)
def set_financial_metrics(self, ticker: str, data: list[dict[str, any]]):
self._financial_metrics_cache[ticker] = self._merge_data(self._financial_metrics_cache.get(ticker), data, key_field="report_period")
def get_line_items(self, ticker: str) -> list[dict[str, any]] | None:
return self._line_items_cache.get(ticker)
def set_line_items(self, ticker: str, data: list[dict[str, any]]):
self._line_items_cache[ticker] = self._merge_data(self._line_items_cache.get(ticker), data, key_field="report_period")
def get_insider_trades(self, ticker: str) -> list[dict[str, any]] | None:
return self._insider_trades_cache.get(ticker)
def set_insider_trades(self, ticker: str, data: list[dict[str, any]]):
self._insider_trades_cache[ticker] = self._merge_data(self._insider_trades_cache.get(ticker), data, key_field="filing_date") # Could also use transaction_date if preferred
def get_company_news(self, ticker: str) -> list[dict[str, any]] | None:
return self._company_news_cache.get(ticker)
def set_company_news(self, ticker: str, data: list[dict[str, any]]):
self._company_news_cache[ticker] = self._merge_data(self._company_news_cache.get(ticker), data, key_field="date")
# Global cache instance
_cache = Cache()
def get_cache() -> Cache:
return _cache | --- +++ @@ -1,4 +1,5 @@ class Cache:
+ """In-memory cache for API responses."""
def __init__(self):
self._prices_cache: dict[str, list[dict[str, any]]] = {}
@@ -8,6 +9,7 @@ self._company_news_cache: dict[str, list[dict[str, any]]] = {}
def _merge_data(self, existing: list[dict] | None, new_data: list[dict], key_field: str) -> list[dict]:
+ """Merge existing and new data, avoiding duplicates based on a key field."""
if not existing:
return new_data
@@ -20,33 +22,43 @@ return merged
def get_prices(self, ticker: str) -> list[dict[str, any]] | None:
+ """Get cached price data if available."""
return self._prices_cache.get(ticker)
def set_prices(self, ticker: str, data: list[dict[str, any]]):
+ """Append new price data to cache."""
self._prices_cache[ticker] = self._merge_data(self._prices_cache.get(ticker), data, key_field="time")
def get_financial_metrics(self, ticker: str) -> list[dict[str, any]]:
+ """Get cached financial metrics if available."""
return self._financial_metrics_cache.get(ticker)
def set_financial_metrics(self, ticker: str, data: list[dict[str, any]]):
+ """Append new financial metrics to cache."""
self._financial_metrics_cache[ticker] = self._merge_data(self._financial_metrics_cache.get(ticker), data, key_field="report_period")
def get_line_items(self, ticker: str) -> list[dict[str, any]] | None:
+ """Get cached line items if available."""
return self._line_items_cache.get(ticker)
def set_line_items(self, ticker: str, data: list[dict[str, any]]):
+ """Append new line items to cache."""
self._line_items_cache[ticker] = self._merge_data(self._line_items_cache.get(ticker), data, key_field="report_period")
def get_insider_trades(self, ticker: str) -> list[dict[str, any]] | None:
+ """Get cached insider trades if available."""
return self._insider_trades_cache.get(ticker)
def set_insider_trades(self, ticker: str, data: list[dict[str, any]]):
+ """Append new insider trades to cache."""
self._insider_trades_cache[ticker] = self._merge_data(self._insider_trades_cache.get(ticker), data, key_field="filing_date") # Could also use transaction_date if preferred
def get_company_news(self, ticker: str) -> list[dict[str, any]] | None:
+ """Get cached company news if available."""
return self._company_news_cache.get(ticker)
def set_company_news(self, ticker: str, data: list[dict[str, any]]):
+ """Append new company news to cache."""
self._company_news_cache[ticker] = self._merge_data(self._company_news_cache.get(ticker), data, key_field="date")
@@ -55,4 +67,5 @@
def get_cache() -> Cache:
- return _cache+ """Get the global cache instance."""
+ return _cache
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/data/cache.py |
Generate descriptive docstrings automatically |
import re
from collections import Counter
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from .cache_service import get_cache
from .parser_service import ParserService
from ..utils.errors import DataNotFoundError
class DataService:
# 中文停用词列表（用于 auto_extract 模式）
STOPWORDS = {
'的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一',
'一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有',
'看', '好', '自己', '这', '那', '来', '被', '与', '为', '对', '将', '从',
'以', '及', '等', '但', '或', '而', '于', '中', '由', '可', '可以', '已',
'已经', '还', '更', '最', '再', '因为', '所以', '如果', '虽然', '然而',
'什么', '怎么', '如何', '哪', '哪些', '多少', '几', '这个', '那个',
'他', '她', '它', '他们', '她们', '我们', '你们', '大家', '自己',
'这样', '那样', '怎样', '这么', '那么', '多么', '非常', '特别',
'应该', '可能', '能够', '需要', '必须', '一定', '肯定', '确实',
'正在', '已经', '曾经', '将要', '即将', '刚刚', '马上', '立刻',
'回应', '发布', '表示', '称', '曝', '官方', '最新', '重磅', '突发',
'热搜', '刷屏', '引发', '关注', '网友', '评论', '转发', '点赞'
}
def __init__(self, project_root: str = None):
self.parser = ParserService(project_root)
self.cache = get_cache()
def get_latest_news(
self,
platforms: Optional[List[str]] = None,
limit: int = 50,
include_url: bool = False
) -> List[Dict]:
# 尝试从缓存获取
cache_key = f"latest_news:{','.join(platforms or [])}:{limit}:{include_url}"
cached = self.cache.get(cache_key, ttl=900) # 15分钟缓存
if cached:
return cached
# 读取今天的数据
all_titles, id_to_name, timestamps = self.parser.read_all_titles_for_date(
date=None,
platform_ids=platforms
)
# 获取最新的文件时间
if timestamps:
latest_timestamp = max(timestamps.values())
fetch_time = datetime.fromtimestamp(latest_timestamp)
else:
fetch_time = datetime.now()
# 转换为新闻列表
news_list = []
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
# 取第一个排名
rank = info["ranks"][0] if info["ranks"] else 0
news_item = {
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"rank": rank,
"timestamp": fetch_time.strftime("%Y-%m-%d %H:%M:%S")
}
# 条件性添加 URL 字段
if include_url:
news_item["url"] = info.get("url", "")
news_item["mobileUrl"] = info.get("mobileUrl", "")
news_list.append(news_item)
# 按排名排序
news_list.sort(key=lambda x: x["rank"])
# 限制返回数量
result = news_list[:limit]
# 缓存结果
self.cache.set(cache_key, result)
return result
def get_news_by_date(
self,
target_date: datetime,
platforms: Optional[List[str]] = None,
limit: int = 50,
include_url: bool = False
) -> List[Dict]:
# 尝试从缓存获取
date_str = target_date.strftime("%Y-%m-%d")
cache_key = f"news_by_date:{date_str}:{','.join(platforms or [])}:{limit}:{include_url}"
cached = self.cache.get(cache_key, ttl=900) # 15分钟缓存
if cached:
return cached
# 读取指定日期的数据
all_titles, id_to_name, timestamps = self.parser.read_all_titles_for_date(
date=target_date,
platform_ids=platforms
)
# 转换为新闻列表
news_list = []
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
# 计算平均排名
avg_rank = sum(info["ranks"]) / len(info["ranks"]) if info["ranks"] else 0
news_item = {
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"rank": info["ranks"][0] if info["ranks"] else 0,
"avg_rank": round(avg_rank, 2),
"count": len(info["ranks"]),
"date": date_str
}
# 条件性添加 URL 字段
if include_url:
news_item["url"] = info.get("url", "")
news_item["mobileUrl"] = info.get("mobileUrl", "")
news_list.append(news_item)
# 按排名排序
news_list.sort(key=lambda x: x["rank"])
# 限制返回数量
result = news_list[:limit]
# 缓存结果(历史数据缓存更久)
self.cache.set(cache_key, result)
return result
def search_news_by_keyword(
self,
keyword: str,
date_range: Optional[Tuple[datetime, datetime]] = None,
platforms: Optional[List[str]] = None,
limit: Optional[int] = None
) -> Dict:
# 确定搜索日期范围
if date_range:
start_date, end_date = date_range
else:
# 默认搜索今天
start_date = end_date = datetime.now()
# 收集所有匹配的新闻
results = []
platform_distribution = Counter()
# 遍历日期范围
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.parser.read_all_titles_for_date(
date=current_date,
platform_ids=platforms
)
# 搜索包含关键词的标题
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
if keyword.lower() in title.lower():
# 计算平均排名
avg_rank = sum(info["ranks"]) / len(info["ranks"]) if info["ranks"] else 0
results.append({
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"ranks": info["ranks"],
"count": len(info["ranks"]),
"avg_rank": round(avg_rank, 2),
"url": info.get("url", ""),
"mobileUrl": info.get("mobileUrl", ""),
"date": current_date.strftime("%Y-%m-%d")
})
platform_distribution[platform_id] += 1
except DataNotFoundError:
# 该日期没有数据,继续下一天
pass
# 下一天
current_date += timedelta(days=1)
if not results:
raise DataNotFoundError(
f"未找到包含关键词 '{keyword}' 的新闻",
suggestion="请尝试其他关键词或扩大日期范围"
)
# 计算统计信息
total_ranks = []
for item in results:
total_ranks.extend(item["ranks"])
avg_rank = sum(total_ranks) / len(total_ranks) if total_ranks else 0
# 限制返回数量(如果指定)
total_found = len(results)
if limit is not None and limit > 0:
results = results[:limit]
return {
"results": results,
"total": len(results),
"total_found": total_found,
"statistics": {
"platform_distribution": dict(platform_distribution),
"avg_rank": round(avg_rank, 2),
"keyword": keyword
}
}
def _extract_words_from_title(self, title: str, min_length: int = 2) -> List[str]:
# 移除URL和特殊字符
title = re.sub(r'http[s]?://\S+', '', title)
title = re.sub(r'\[.*?\]', '', title) # 移除方括号内容
title = re.sub(r'[【】《》「」『』""''・·•]', '', title) # 移除中文标点
# 使用正则表达式分词（中文和英文）
# 匹配连续的中文字符或英文单词
words = re.findall(r'[\u4e00-\u9fff]{2,}|[a-zA-Z]{2,}[a-zA-Z0-9]*', title)
# 过滤停用词和短词
keywords = [
word for word in words
if word and len(word) >= min_length and word.lower() not in self.STOPWORDS
and word not in self.STOPWORDS
]
return keywords
def get_trending_topics(
self,
top_n: int = 10,
mode: str = "current",
extract_mode: str = "keywords"
) -> Dict:
# 尝试从缓存获取
cache_key = f"trending_topics:{top_n}:{mode}:{extract_mode}"
cached = self.cache.get(cache_key, ttl=900) # 15分钟缓存
if cached:
return cached
# 读取今天的数据
all_titles, id_to_name, timestamps = self.parser.read_all_titles_for_date()
if not all_titles:
raise DataNotFoundError(
"未找到今天的新闻数据",
suggestion="请确保爬虫已经运行并生成了数据"
)
# 根据 mode 选择要处理的标题数据
if mode == "daily":
titles_to_process = all_titles
elif mode == "current":
titles_to_process = all_titles # 简化实现
else:
raise ValueError(f"不支持的模式: {mode}。支持的模式: daily, current")
# 统计词频
word_frequency = Counter()
keyword_to_news = {}
# 预加载关键词数据（避免在循环内重复调用）
if extract_mode == "keywords":
from trendradar.core.frequency import _word_matches
word_groups = self.parser.parse_frequency_words()
# 遍历要处理的标题
for platform_id, titles in titles_to_process.items():
for title in titles.keys():
if extract_mode == "keywords":
# 基于预设关键词统计（支持正则匹配）
title_lower = title.lower()
for group in word_groups:
all_words = group.get("required", []) + group.get("normal", [])
# 检查是否匹配词组中的任意一个词
matched = any(_word_matches(word_config, title_lower) for word_config in all_words)
if matched:
# 使用组的 display_name（组别名或行别名拼接）
display_key = group.get("display_name") or group.get("group_key", "")
word_frequency[display_key] += 1
if display_key not in keyword_to_news:
keyword_to_news[display_key] = []
keyword_to_news[display_key].append(title)
break # 每个标题只计入第一个匹配的词组
elif extract_mode == "auto_extract":
# 自动提取关键词
extracted_words = self._extract_words_from_title(title)
for word in extracted_words:
word_frequency[word] += 1
if word not in keyword_to_news:
keyword_to_news[word] = []
keyword_to_news[word].append(title)
# 获取TOP N关键词
top_keywords = word_frequency.most_common(top_n)
# 构建话题列表
topics = []
for keyword, frequency in top_keywords:
matched_news = keyword_to_news.get(keyword, [])
topics.append({
"keyword": keyword,
"frequency": frequency,
"matched_news": len(set(matched_news)), # 去重后的新闻数量
"trend": "stable",
"weight_score": 0.0
})
# 构建结果
result = {
"topics": topics,
"generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"mode": mode,
"extract_mode": extract_mode,
"total_keywords": len(word_frequency),
"description": self._get_mode_description(mode, extract_mode)
}
# 缓存结果
self.cache.set(cache_key, result)
return result
def _get_mode_description(self, mode: str, extract_mode: str = "keywords") -> str:
mode_desc = {
"daily": "当日累计统计",
"current": "最新一批统计"
}.get(mode, "未知时间模式")
extract_desc = {
"keywords": "基于预设关注词",
"auto_extract": "自动提取高频词"
}.get(extract_mode, "未知提取模式")
return f"{mode_desc} - {extract_desc}"
def get_current_config(self, section: str = "all") -> Dict:
# 解析配置文件
config_data = self.parser.parse_yaml_config()
word_groups = self.parser.parse_frequency_words()
# 根据section返回对应配置
advanced = config_data.get("advanced", {})
advanced_crawler = advanced.get("crawler", {})
platforms_config = config_data.get("platforms", {})
if section == "all" or section == "crawler":
crawler_config = {
"enable_crawler": platforms_config.get("enabled", True),
"use_proxy": advanced_crawler.get("use_proxy", False),
"request_interval": advanced_crawler.get("request_interval", 1),
"retry_times": 3,
"platforms": [p["id"] for p in platforms_config.get("sources", [])]
}
if section == "all" or section == "push":
notification = config_data.get("notification", {})
batch_size = advanced.get("batch_size", {})
push_config = {
"enable_notification": notification.get("enabled", True),
"enabled_channels": [],
"message_batch_size": batch_size.get("default", 4000),
"push_window": {} # 已迁移至调度系统（schedule + timeline.yaml）
}
# 检测已配置的通知渠道（合并 config.yaml + .env）
from trendradar.core.loader import _load_webhook_config
webhook_config = _load_webhook_config(config_data)
channel_checks = {
"feishu": [webhook_config.get("FEISHU_WEBHOOK_URL")],
"dingtalk": [webhook_config.get("DINGTALK_WEBHOOK_URL")],
"wework": [webhook_config.get("WEWORK_WEBHOOK_URL")],
"telegram": [webhook_config.get("TELEGRAM_BOT_TOKEN"), webhook_config.get("TELEGRAM_CHAT_ID")],
"email": [webhook_config.get("EMAIL_FROM"), webhook_config.get("EMAIL_PASSWORD"), webhook_config.get("EMAIL_TO")],
"ntfy": [webhook_config.get("NTFY_SERVER_URL"), webhook_config.get("NTFY_TOPIC")],
"bark": [webhook_config.get("BARK_URL")],
"slack": [webhook_config.get("SLACK_WEBHOOK_URL")],
"generic_webhook": [webhook_config.get("GENERIC_WEBHOOK_URL")],
}
for ch_id, required_values in channel_checks.items():
if all(required_values):
push_config["enabled_channels"].append(ch_id)
if section == "all" or section == "keywords":
keywords_config = {
"word_groups": word_groups,
"total_groups": len(word_groups)
}
if section == "all" or section == "weights":
weight = advanced.get("weight", {})
weights_config = {
"rank_weight": weight.get("rank", 0.6),
"frequency_weight": weight.get("frequency", 0.3),
"hotness_weight": weight.get("hotness", 0.1)
}
# 组装结果
if section == "all":
result = {
"crawler": crawler_config,
"push": push_config,
"keywords": keywords_config,
"weights": weights_config
}
elif section == "crawler":
result = crawler_config
elif section == "push":
result = push_config
elif section == "keywords":
result = keywords_config
elif section == "weights":
result = weights_config
else:
result = {}
return result
def get_available_date_range(self, db_type: str = "news") -> Tuple[Optional[datetime], Optional[datetime]]:
return self.parser.get_available_date_range(db_type)
def get_system_status(self) -> Dict:
# 获取数据统计
output_dir = self.parser.project_root / "output"
total_storage = 0
# 使用 parser 的方法获取日期范围
oldest_record, latest_record = self.get_available_date_range(db_type="news")
# 计算 output 目录总存储大小
if output_dir.exists():
for item in output_dir.rglob("*"):
if item.is_file():
total_storage += item.stat().st_size
# 读取版本信息
version_file = self.parser.project_root / "version"
version = "unknown"
if version_file.exists():
try:
with open(version_file, "r") as f:
version = f.read().strip()
except:
pass
return {
"system": {
"version": version,
"project_root": str(self.parser.project_root)
},
"data": {
"total_storage": f"{total_storage / 1024 / 1024:.2f} MB",
"oldest_record": oldest_record.strftime("%Y-%m-%d") if oldest_record else None,
"latest_record": latest_record.strftime("%Y-%m-%d") if latest_record else None,
},
"cache": self.cache.get_stats(),
"health": "healthy"
}
# ========================================
# RSS 数据查询方法
# ========================================
def get_latest_rss(
self,
feeds: Optional[List[str]] = None,
days: int = 1,
limit: int = 50,
include_summary: bool = False
) -> List[Dict]:
days = min(max(days, 1), 30) # 限制 1-30 天
cache_key = f"latest_rss:{','.join(feeds or [])}:{days}:{limit}:{include_summary}"
cached = self.cache.get(cache_key, ttl=900)
if cached:
return cached
rss_list = []
seen_urls = set() # 跨日期 URL 去重
today = datetime.now()
for i in range(days):
target_date = today - timedelta(days=i)
try:
all_items, id_to_name, timestamps = self.parser.read_all_titles_for_date(
date=target_date,
platform_ids=feeds,
db_type="rss"
)
# 获取抓取时间
if timestamps:
latest_timestamp = max(timestamps.values())
fetch_time = datetime.fromtimestamp(latest_timestamp)
else:
fetch_time = target_date
# 转换为列表
for feed_id, items in all_items.items():
feed_name = id_to_name.get(feed_id, feed_id)
for title, info in items.items():
# 跨日期 URL 去重
url = info.get("url", "")
if url and url in seen_urls:
continue
if url:
seen_urls.add(url)
rss_item = {
"title": title,
"feed_id": feed_id,
"feed_name": feed_name,
"url": url,
"published_at": info.get("published_at", ""),
"author": info.get("author", ""),
"date": target_date.strftime("%Y-%m-%d"),
"fetch_time": fetch_time.strftime("%Y-%m-%d %H:%M:%S") if isinstance(fetch_time, datetime) else target_date.strftime("%Y-%m-%d")
}
if include_summary:
rss_item["summary"] = info.get("summary", "")
rss_list.append(rss_item)
except DataNotFoundError:
continue
# 按发布时间排序（最新的在前）
rss_list.sort(key=lambda x: x.get("published_at", ""), reverse=True)
# 限制返回数量
result = rss_list[:limit]
# 缓存结果
self.cache.set(cache_key, result)
return result
def search_rss(
self,
keyword: str,
feeds: Optional[List[str]] = None,
days: int = 7,
limit: int = 50,
include_summary: bool = False
) -> List[Dict]:
cache_key = f"search_rss:{keyword}:{','.join(feeds or [])}:{days}:{limit}:{include_summary}"
cached = self.cache.get(cache_key, ttl=900)
if cached:
return cached
results = []
seen_urls = set() # 用于 URL 去重
today = datetime.now()
for i in range(days):
target_date = today - timedelta(days=i)
try:
all_items, id_to_name, _ = self.parser.read_all_titles_for_date(
date=target_date,
platform_ids=feeds,
db_type="rss"
)
for feed_id, items in all_items.items():
feed_name = id_to_name.get(feed_id, feed_id)
for title, info in items.items():
# 跨日期去重：如果 URL 已出现过则跳过
url = info.get("url", "")
if url and url in seen_urls:
continue
if url:
seen_urls.add(url)
# 关键词匹配（标题或摘要）
summary = info.get("summary", "")
if keyword.lower() in title.lower() or keyword.lower() in summary.lower():
rss_item = {
"title": title,
"feed_id": feed_id,
"feed_name": feed_name,
"url": url,
"published_at": info.get("published_at", ""),
"author": info.get("author", ""),
"date": target_date.strftime("%Y-%m-%d")
}
if include_summary:
rss_item["summary"] = summary
results.append(rss_item)
except DataNotFoundError:
continue
# 按发布时间排序
results.sort(key=lambda x: x.get("published_at", ""), reverse=True)
# 限制返回数量
result = results[:limit]
# 缓存结果
self.cache.set(cache_key, result)
return result
def get_rss_feeds_status(self) -> Dict:
cache_key = "rss_feeds_status"
cached = self.cache.get(cache_key, ttl=900)
if cached:
return cached
# 获取可用的 RSS 日期
available_dates = self.parser.get_available_dates(db_type="rss")
# 获取今天的 RSS 数据统计
today_stats = {}
try:
all_items, id_to_name, _ = self.parser.read_all_titles_for_date(
date=None,
platform_ids=None,
db_type="rss"
)
for feed_id, items in all_items.items():
today_stats[feed_id] = {
"name": id_to_name.get(feed_id, feed_id),
"item_count": len(items)
}
except DataNotFoundError:
pass
result = {
"available_dates": available_dates[:10], # 最近 10 天
"total_dates": len(available_dates),
"today_feeds": today_stats,
"generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
}
self.cache.set(cache_key, result)
return result | --- +++ @@ -1,3 +1,8 @@+"""
+数据访问服务
+
+提供统一的数据查询接口,封装数据访问逻辑。
+"""
import re
from collections import Counter
@@ -10,6 +15,7 @@
class DataService:
+ """数据访问服务类"""
# 中文停用词列表（用于 auto_extract 模式）
STOPWORDS = {
@@ -28,6 +34,12 @@ }
def __init__(self, project_root: str = None):
+ """
+ 初始化数据服务
+
+ Args:
+ project_root: 项目根目录
+ """
self.parser = ParserService(project_root)
self.cache = get_cache()
@@ -37,6 +49,20 @@ limit: int = 50,
include_url: bool = False
) -> List[Dict]:
+ """
+ 获取最新一批爬取的新闻数据
+
+ Args:
+ platforms: 平台ID列表,None表示所有平台
+ limit: 返回条数限制
+ include_url: 是否包含URL链接,默认False(节省token)
+
+ Returns:
+ 新闻列表
+
+ Raises:
+ DataNotFoundError: 数据不存在
+ """
# 尝试从缓存获取
cache_key = f"latest_news:{','.join(platforms or [])}:{limit}:{include_url}"
cached = self.cache.get(cache_key, ttl=900) # 15分钟缓存
@@ -98,6 +124,29 @@ limit: int = 50,
include_url: bool = False
) -> List[Dict]:
+ """
+ 按指定日期获取新闻
+
+ Args:
+ target_date: 目标日期
+ platforms: 平台ID列表,None表示所有平台
+ limit: 返回条数限制
+ include_url: 是否包含URL链接,默认False(节省token)
+
+ Returns:
+ 新闻列表
+
+ Raises:
+ DataNotFoundError: 数据不存在
+
+ Examples:
+ >>> service = DataService()
+ >>> news = service.get_news_by_date(
+ ... target_date=datetime(2025, 10, 10),
+ ... platforms=['zhihu'],
+ ... limit=20
+ ... )
+ """
# 尝试从缓存获取
date_str = target_date.strftime("%Y-%m-%d")
cache_key = f"news_by_date:{date_str}:{','.join(platforms or [])}:{limit}:{include_url}"
@@ -155,6 +204,21 @@ platforms: Optional[List[str]] = None,
limit: Optional[int] = None
) -> Dict:
+ """
+ 按关键词搜索新闻
+
+ Args:
+ keyword: 搜索关键词
+ date_range: 日期范围 (start_date, end_date)
+ platforms: 平台过滤列表
+ limit: 返回条数限制(可选)
+
+ Returns:
+ 搜索结果字典
+
+ Raises:
+ DataNotFoundError: 数据不存在
+ """
# 确定搜索日期范围
if date_range:
start_date, end_date = date_range
@@ -235,6 +299,16 @@ }
def _extract_words_from_title(self, title: str, min_length: int = 2) -> List[str]:
+ """
+ 从标题中提取有意义的词语（用于 auto_extract 模式）
+
+ Args:
+ title: 新闻标题
+ min_length: 最小词长
+
+ Returns:
+ 关键词列表
+ """
# 移除URL和特殊字符
title = re.sub(r'http[s]?://\S+', '', title)
title = re.sub(r'\[.*?\]', '', title) # 移除方括号内容
@@ -259,6 +333,24 @@ mode: str = "current",
extract_mode: str = "keywords"
) -> Dict:
+ """
+ 获取热点话题统计
+
+ Args:
+ top_n: 返回TOP N话题
+ mode: 时间模式
+ - "daily": 当日累计数据统计
+ - "current": 最新一批数据统计（默认）
+ extract_mode: 提取模式
+ - "keywords": 统计预设关注词（基于 config/frequency_words.txt）
+ - "auto_extract": 自动从新闻标题提取高频词
+
+ Returns:
+ 话题频率统计字典
+
+ Raises:
+ DataNotFoundError: 数据不存在
+ """
# 尝试从缓存获取
cache_key = f"trending_topics:{top_n}:{mode}:{extract_mode}"
cached = self.cache.get(cache_key, ttl=900) # 15分钟缓存
@@ -354,6 +446,7 @@ return result
def _get_mode_description(self, mode: str, extract_mode: str = "keywords") -> str:
+ """获取模式描述"""
mode_desc = {
"daily": "当日累计统计",
"current": "最新一批统计"
@@ -367,6 +460,18 @@ return f"{mode_desc} - {extract_desc}"
def get_current_config(self, section: str = "all") -> Dict:
+ """
+ 获取当前系统配置
+
+ Args:
+ section: 配置节 - all/crawler/push/keywords/weights
+
+ Returns:
+ 配置字典
+
+ Raises:
+ FileParseError: 配置文件解析错误
+ """
# 解析配置文件
config_data = self.parser.parse_yaml_config()
word_groups = self.parser.parse_frequency_words()
@@ -451,9 +556,29 @@ return result
def get_available_date_range(self, db_type: str = "news") -> Tuple[Optional[datetime], Optional[datetime]]:
+ """
+ 扫描 output 目录，返回实际可用的日期范围
+
+ Args:
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ (最早日期, 最新日期) 元组，如果没有数据则返回 (None, None)
+
+ Examples:
+ >>> service = DataService()
+ >>> earliest, latest = service.get_available_date_range()
+ >>> print(f"可用日期范围：{earliest} 至 {latest}")
+ """
return self.parser.get_available_date_range(db_type)
def get_system_status(self) -> Dict:
+ """
+ 获取系统运行状态
+
+ Returns:
+ 系统状态字典
+ """
# 获取数据统计
output_dir = self.parser.project_root / "output"
@@ -503,6 +628,21 @@ limit: int = 50,
include_summary: bool = False
) -> List[Dict]:
+ """
+ 获取最新的 RSS 数据（支持多日查询）
+
+ Args:
+ feeds: RSS 源 ID 列表，None 表示所有源
+ days: 获取最近 N 天的数据，默认 1（仅今天），最大 30 天
+ limit: 返回条数限制
+ include_summary: 是否包含摘要，默认 False（节省 token）
+
+ Returns:
+ RSS 条目列表（按 URL 去重）
+
+ Raises:
+ DataNotFoundError: 数据不存在
+ """
days = min(max(days, 1), 30) # 限制 1-30 天
cache_key = f"latest_rss:{','.join(feeds or [])}:{days}:{limit}:{include_summary}"
cached = self.cache.get(cache_key, ttl=900)
@@ -580,6 +720,19 @@ limit: int = 50,
include_summary: bool = False
) -> List[Dict]:
+ """
+ 搜索 RSS 数据（跨日期自动去重）
+
+ Args:
+ keyword: 搜索关键词
+ feeds: RSS 源 ID 列表，None 表示所有源
+ days: 搜索最近 N 天的数据
+ limit: 返回条数限制
+ include_summary: 是否包含摘要
+
+ Returns:
+ 匹配的 RSS 条目列表（按 URL 去重）
+ """
cache_key = f"search_rss:{keyword}:{','.join(feeds or [])}:{days}:{limit}:{include_summary}"
cached = self.cache.get(cache_key, ttl=900)
if cached:
@@ -643,6 +796,12 @@ return result
def get_rss_feeds_status(self) -> Dict:
+ """
+ 获取 RSS 源状态
+
+ Returns:
+ RSS 源状态信息
+ """
cache_key = "rss_feeds_status"
cached = self.cache.get(cache_key, ttl=900)
if cached:
@@ -678,4 +837,4 @@
self.cache.set(cache_key, result)
- return result+ return result
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/services/data_service.py |
Add clean documentation to messy code | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_financial_metrics, get_market_cap, search_line_items
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
from src.utils.api_key import get_api_key_from_state
class MohnishPabraiSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def mohnish_pabrai_agent(state: AgentState, agent_id: str = "mohnish_pabrai_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data: dict[str, any] = {}
pabrai_analysis: dict[str, any] = {}
# Pabrai focuses on: downside protection, simple business, moat via unit economics, FCF yield vs alternatives,
# and potential for doubling in 2-3 years at low risk.
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="annual", limit=8, api_key=api_key)
progress.update_status(agent_id, ticker, "Gathering financial line items")
line_items = search_line_items(
ticker,
[
# Profitability and cash generation
"revenue",
"gross_profit",
"gross_margin",
"operating_income",
"operating_margin",
"net_income",
"free_cash_flow",
# Balance sheet - debt and liquidity
"total_debt",
"cash_and_equivalents",
"current_assets",
"current_liabilities",
"shareholders_equity",
# Capital intensity
"capital_expenditure",
"depreciation_and_amortization",
# Shares outstanding for per-share context
"outstanding_shares",
],
end_date,
period="annual",
limit=8,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing downside protection")
downside = analyze_downside_protection(line_items)
progress.update_status(agent_id, ticker, "Analyzing cash yield and valuation")
valuation = analyze_pabrai_valuation(line_items, market_cap)
progress.update_status(agent_id, ticker, "Assessing potential to double")
double_potential = analyze_double_potential(line_items, market_cap)
# Combine to an overall score in spirit of Pabrai: heavily weight downside and cash yield
total_score = (
downside["score"] * 0.45
+ valuation["score"] * 0.35
+ double_potential["score"] * 0.20
)
max_score = 10
if total_score >= 7.5:
signal = "bullish"
elif total_score <= 4.0:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_score,
"downside_protection": downside,
"valuation": valuation,
"double_potential": double_potential,
"market_cap": market_cap,
}
progress.update_status(agent_id, ticker, "Generating Pabrai analysis")
pabrai_output = generate_pabrai_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
pabrai_analysis[ticker] = {
"signal": pabrai_output.signal,
"confidence": pabrai_output.confidence,
"reasoning": pabrai_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=pabrai_output.reasoning)
message = HumanMessage(content=json.dumps(pabrai_analysis), name=agent_id)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(pabrai_analysis, "Mohnish Pabrai Agent")
progress.update_status(agent_id, None, "Done")
state["data"]["analyst_signals"][agent_id] = pabrai_analysis
return {"messages": [message], "data": state["data"]}
def analyze_downside_protection(financial_line_items: list) -> dict[str, any]:
if not financial_line_items:
return {"score": 0, "details": "Insufficient data"}
latest = financial_line_items[0]
details: list[str] = []
score = 0
cash = getattr(latest, "cash_and_equivalents", None)
debt = getattr(latest, "total_debt", None)
current_assets = getattr(latest, "current_assets", None)
current_liabilities = getattr(latest, "current_liabilities", None)
equity = getattr(latest, "shareholders_equity", None)
# Net cash position is a strong downside protector
net_cash = None
if cash is not None and debt is not None:
net_cash = cash - debt
if net_cash > 0:
score += 3
details.append(f"Net cash position: ${net_cash:,.0f}")
else:
details.append(f"Net debt position: ${net_cash:,.0f}")
# Current ratio
if current_assets is not None and current_liabilities is not None and current_liabilities > 0:
current_ratio = current_assets / current_liabilities
if current_ratio >= 2.0:
score += 2
details.append(f"Strong liquidity (current ratio {current_ratio:.2f})")
elif current_ratio >= 1.2:
score += 1
details.append(f"Adequate liquidity (current ratio {current_ratio:.2f})")
else:
details.append(f"Weak liquidity (current ratio {current_ratio:.2f})")
# Low leverage
if equity is not None and equity > 0 and debt is not None:
de_ratio = debt / equity
if de_ratio < 0.3:
score += 2
details.append(f"Very low leverage (D/E {de_ratio:.2f})")
elif de_ratio < 0.7:
score += 1
details.append(f"Moderate leverage (D/E {de_ratio:.2f})")
else:
details.append(f"High leverage (D/E {de_ratio:.2f})")
# Free cash flow positive and stable
fcf_values = [getattr(li, "free_cash_flow", None) for li in financial_line_items if getattr(li, "free_cash_flow", None) is not None]
if fcf_values and len(fcf_values) >= 3:
recent_avg = sum(fcf_values[:3]) / 3
older = sum(fcf_values[-3:]) / 3 if len(fcf_values) >= 6 else fcf_values[-1]
if recent_avg > 0 and recent_avg >= older:
score += 2
details.append("Positive and improving/stable FCF")
elif recent_avg > 0:
score += 1
details.append("Positive but declining FCF")
else:
details.append("Negative FCF")
return {"score": min(10, score), "details": "; ".join(details)}
def analyze_pabrai_valuation(financial_line_items: list, market_cap: float | None) -> dict[str, any]:
if not financial_line_items or market_cap is None or market_cap <= 0:
return {"score": 0, "details": "Insufficient data", "fcf_yield": None, "normalized_fcf": None}
details: list[str] = []
fcf_values = [getattr(li, "free_cash_flow", None) for li in financial_line_items if getattr(li, "free_cash_flow", None) is not None]
capex_vals = [abs(getattr(li, "capital_expenditure", 0) or 0) for li in financial_line_items]
if not fcf_values or len(fcf_values) < 3:
return {"score": 0, "details": "Insufficient FCF history", "fcf_yield": None, "normalized_fcf": None}
normalized_fcf = sum(fcf_values[:min(5, len(fcf_values))]) / min(5, len(fcf_values))
if normalized_fcf <= 0:
return {"score": 0, "details": "Non-positive normalized FCF", "fcf_yield": None, "normalized_fcf": normalized_fcf}
fcf_yield = normalized_fcf / market_cap
score = 0
if fcf_yield > 0.10:
score += 4
details.append(f"Exceptional value: {fcf_yield:.1%} FCF yield")
elif fcf_yield > 0.07:
score += 3
details.append(f"Attractive value: {fcf_yield:.1%} FCF yield")
elif fcf_yield > 0.05:
score += 2
details.append(f"Reasonable value: {fcf_yield:.1%} FCF yield")
elif fcf_yield > 0.03:
score += 1
details.append(f"Borderline value: {fcf_yield:.1%} FCF yield")
else:
details.append(f"Expensive: {fcf_yield:.1%} FCF yield")
# Asset-light tilt: lower capex intensity preferred
if capex_vals and len(financial_line_items) >= 3:
revenue_vals = [getattr(li, "revenue", None) for li in financial_line_items]
capex_to_revenue = []
for i, li in enumerate(financial_line_items):
revenue = getattr(li, "revenue", None)
capex = abs(getattr(li, "capital_expenditure", 0) or 0)
if revenue and revenue > 0:
capex_to_revenue.append(capex / revenue)
if capex_to_revenue:
avg_ratio = sum(capex_to_revenue) / len(capex_to_revenue)
if avg_ratio < 0.05:
score += 2
details.append(f"Asset-light: Avg capex {avg_ratio:.1%} of revenue")
elif avg_ratio < 0.10:
score += 1
details.append(f"Moderate capex: Avg capex {avg_ratio:.1%} of revenue")
else:
details.append(f"Capex heavy: Avg capex {avg_ratio:.1%} of revenue")
return {"score": min(10, score), "details": "; ".join(details), "fcf_yield": fcf_yield, "normalized_fcf": normalized_fcf}
def analyze_double_potential(financial_line_items: list, market_cap: float | None) -> dict[str, any]:
if not financial_line_items or market_cap is None or market_cap <= 0:
return {"score": 0, "details": "Insufficient data"}
details: list[str] = []
# Use revenue and FCF trends as rough growth proxy (keep it simple)
revenues = [getattr(li, "revenue", None) for li in financial_line_items if getattr(li, "revenue", None) is not None]
fcfs = [getattr(li, "free_cash_flow", None) for li in financial_line_items if getattr(li, "free_cash_flow", None) is not None]
score = 0
if revenues and len(revenues) >= 3:
recent_rev = sum(revenues[:3]) / 3
older_rev = sum(revenues[-3:]) / 3 if len(revenues) >= 6 else revenues[-1]
if older_rev > 0:
rev_growth = (recent_rev / older_rev) - 1
if rev_growth > 0.15:
score += 2
details.append(f"Strong revenue trajectory ({rev_growth:.1%})")
elif rev_growth > 0.05:
score += 1
details.append(f"Modest revenue growth ({rev_growth:.1%})")
if fcfs and len(fcfs) >= 3:
recent_fcf = sum(fcfs[:3]) / 3
older_fcf = sum(fcfs[-3:]) / 3 if len(fcfs) >= 6 else fcfs[-1]
if older_fcf != 0:
fcf_growth = (recent_fcf / older_fcf) - 1
if fcf_growth > 0.20:
score += 3
details.append(f"Strong FCF growth ({fcf_growth:.1%})")
elif fcf_growth > 0.08:
score += 2
details.append(f"Healthy FCF growth ({fcf_growth:.1%})")
elif fcf_growth > 0:
score += 1
details.append(f"Positive FCF growth ({fcf_growth:.1%})")
# If FCF yield is already high (>8%), doubling can come from cash generation alone in few years
tmp_val = analyze_pabrai_valuation(financial_line_items, market_cap)
fcf_yield = tmp_val.get("fcf_yield")
if fcf_yield is not None:
if fcf_yield > 0.08:
score += 3
details.append("High FCF yield can drive doubling via retained cash/Buybacks")
elif fcf_yield > 0.05:
score += 1
details.append("Reasonable FCF yield supports moderate compounding")
return {"score": min(10, score), "details": "; ".join(details)}
def generate_pabrai_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> MohnishPabraiSignal:
template = ChatPromptTemplate.from_messages([
(
"system",
"""You are Mohnish Pabrai. Apply my value investing philosophy:
- Heads I win; tails I don't lose much: prioritize downside protection first.
- Buy businesses with simple, understandable models and durable moats.
- Demand high free cash flow yields and low leverage; prefer asset-light models.
- Look for situations where intrinsic value is rising and price is significantly lower.
- Favor cloning great investors' ideas and checklists over novelty.
- Seek potential to double capital in 2-3 years with low risk.
- Avoid leverage, complexity, and fragile balance sheets.
Provide candid, checklist-driven reasoning, with emphasis on capital preservation and expected mispricing.
""",
),
(
"human",
"""Analyze {ticker} using the provided data.
DATA:
{analysis_data}
Return EXACTLY this JSON:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": float (0-100),
"reasoning": "string with Pabrai-style analysis focusing on downside protection, FCF yield, and doubling potential"
}}
""",
),
])
prompt = template.invoke({
"analysis_data": json.dumps(analysis_data, indent=2),
"ticker": ticker,
})
def create_default_pabrai_signal():
return MohnishPabraiSignal(signal="neutral", confidence=0.0, reasoning="Error in analysis, defaulting to neutral")
return call_llm(
prompt=prompt,
state=state,
pydantic_model=MohnishPabraiSignal,
agent_name=agent_id,
default_factory=create_default_pabrai_signal,
) | --- +++ @@ -17,6 +17,7 @@
def mohnish_pabrai_agent(state: AgentState, agent_id: str = "mohnish_pabrai_agent"):
+ """Evaluate stocks using Mohnish Pabrai's checklist and 'heads I win, tails I don't lose much' approach."""
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -127,6 +128,7 @@
def analyze_downside_protection(financial_line_items: list) -> dict[str, any]:
+ """Assess balance-sheet strength and downside resiliency (capital preservation first)."""
if not financial_line_items:
return {"score": 0, "details": "Insufficient data"}
@@ -192,6 +194,7 @@
def analyze_pabrai_valuation(financial_line_items: list, market_cap: float | None) -> dict[str, any]:
+ """Value via simple FCF yield and asset-light preference (keep it simple, low mistakes)."""
if not financial_line_items or market_cap is None or market_cap <= 0:
return {"score": 0, "details": "Insufficient data", "fcf_yield": None, "normalized_fcf": None}
@@ -248,6 +251,7 @@
def analyze_double_potential(financial_line_items: list, market_cap: float | None) -> dict[str, any]:
+ """Estimate low-risk path to double capital in ~2-3 years: runway from FCF growth + rerating."""
if not financial_line_items or market_cap is None or market_cap <= 0:
return {"score": 0, "details": "Insufficient data"}
@@ -305,6 +309,7 @@ state: AgentState,
agent_id: str,
) -> MohnishPabraiSignal:
+ """Generate Pabrai-style decision focusing on low risk, high uncertainty bets and cloning."""
template = ChatPromptTemplate.from_messages([
(
"system",
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/mohnish_pabrai.py |
Create documentation strings for testing functions |
import re
import sqlite3
from pathlib import Path
from typing import Dict, List, Tuple, Optional
from datetime import datetime
import yaml
from ..utils.errors import FileParseError, DataNotFoundError
from .cache_service import get_cache
class ParserService:
def __init__(self, project_root: str = None):
if project_root is None:
current_file = Path(__file__)
self.project_root = current_file.parent.parent.parent
else:
self.project_root = Path(project_root)
self.cache = get_cache()
# frequency_words.txt mtime 缓存
self._freq_words_cache: Optional[List[Dict]] = None
self._freq_words_mtime: float = 0.0
@staticmethod
def clean_title(title: str) -> str:
title = re.sub(r'\s+', ' ', title)
title = title.strip()
return title
def get_date_folder_name(self, date: datetime = None) -> str:
if date is None:
date = datetime.now()
return date.strftime("%Y-%m-%d")
def _get_db_path(self, date: datetime = None, db_type: str = "news") -> Optional[Path]:
date_str = self.get_date_folder_name(date)
db_path = self.project_root / "output" / db_type / f"{date_str}.db"
if db_path.exists():
return db_path
return None
def _read_from_sqlite(
self,
date: datetime = None,
platform_ids: Optional[List[str]] = None,
db_type: str = "news"
) -> Optional[Tuple[Dict, Dict, Dict]]:
db_path = self._get_db_path(date, db_type)
if db_path is None:
return None
all_titles = {}
id_to_name = {}
all_timestamps = {}
try:
conn = sqlite3.connect(str(db_path))
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
if db_type == "news":
return self._read_news_from_sqlite(cursor, platform_ids, all_titles, id_to_name, all_timestamps)
elif db_type == "rss":
return self._read_rss_from_sqlite(cursor, platform_ids, all_titles, id_to_name, all_timestamps)
except Exception as e:
print(f"Warning: 从 SQLite 读取数据失败: {e}")
return None
finally:
if 'conn' in locals():
conn.close()
def _read_news_from_sqlite(
self,
cursor,
platform_ids: Optional[List[str]],
all_titles: Dict,
id_to_name: Dict,
all_timestamps: Dict
) -> Optional[Tuple[Dict, Dict, Dict]]:
# 检查表是否存在
cursor.execute("""
SELECT name FROM sqlite_master
WHERE type='table' AND name='news_items'
""")
if not cursor.fetchone():
return None
# 构建查询
if platform_ids:
placeholders = ','.join(['?' for _ in platform_ids])
query = f"""
SELECT n.id, n.platform_id, p.name as platform_name, n.title,
n.rank, n.url, n.mobile_url,
n.first_crawl_time, n.last_crawl_time, n.crawl_count
FROM news_items n
LEFT JOIN platforms p ON n.platform_id = p.id
WHERE n.platform_id IN ({placeholders})
"""
cursor.execute(query, platform_ids)
else:
cursor.execute("""
SELECT n.id, n.platform_id, p.name as platform_name, n.title,
n.rank, n.url, n.mobile_url,
n.first_crawl_time, n.last_crawl_time, n.crawl_count
FROM news_items n
LEFT JOIN platforms p ON n.platform_id = p.id
""")
rows = cursor.fetchall()
# 收集所有 news_item_id 用于查询历史排名
news_ids = [row['id'] for row in rows]
rank_history_map = {}
if news_ids:
placeholders = ",".join("?" * len(news_ids))
cursor.execute(f"""
SELECT news_item_id, rank FROM rank_history
WHERE news_item_id IN ({placeholders})
ORDER BY news_item_id, crawl_time
""", news_ids)
for rh_row in cursor.fetchall():
news_id = rh_row['news_item_id']
rank = rh_row['rank']
if news_id not in rank_history_map:
rank_history_map[news_id] = []
rank_history_map[news_id].append(rank)
for row in rows:
news_id = row['id']
platform_id = row['platform_id']
platform_name = row['platform_name'] or platform_id
title = row['title']
if platform_id not in id_to_name:
id_to_name[platform_id] = platform_name
if platform_id not in all_titles:
all_titles[platform_id] = {}
ranks = rank_history_map.get(news_id, [row['rank']])
all_titles[platform_id][title] = {
"ranks": ranks,
"url": row['url'] or "",
"mobileUrl": row['mobile_url'] or "",
"first_time": row['first_crawl_time'] or "",
"last_time": row['last_crawl_time'] or "",
"count": row['crawl_count'] or 1,
}
# 获取抓取时间作为 timestamps
cursor.execute("""
SELECT crawl_time, created_at FROM crawl_records
ORDER BY crawl_time
""")
for row in cursor.fetchall():
crawl_time = row['crawl_time']
created_at = row['created_at']
try:
ts = datetime.strptime(created_at, "%Y-%m-%d %H:%M:%S").timestamp()
except (ValueError, TypeError):
ts = datetime.now().timestamp()
all_timestamps[f"{crawl_time}.db"] = ts
if not all_titles:
return None
return (all_titles, id_to_name, all_timestamps)
def _read_rss_from_sqlite(
self,
cursor,
feed_ids: Optional[List[str]],
all_items: Dict,
id_to_name: Dict,
all_timestamps: Dict
) -> Optional[Tuple[Dict, Dict, Dict]]:
# 检查表是否存在
cursor.execute("""
SELECT name FROM sqlite_master
WHERE type='table' AND name='rss_items'
""")
if not cursor.fetchone():
return None
# 构建查询
if feed_ids:
placeholders = ','.join(['?' for _ in feed_ids])
query = f"""
SELECT i.id, i.feed_id, f.name as feed_name, i.title,
i.url, i.published_at, i.summary, i.author,
i.first_crawl_time, i.last_crawl_time, i.crawl_count
FROM rss_items i
LEFT JOIN rss_feeds f ON i.feed_id = f.id
WHERE i.feed_id IN ({placeholders})
ORDER BY i.published_at DESC
"""
cursor.execute(query, feed_ids)
else:
cursor.execute("""
SELECT i.id, i.feed_id, f.name as feed_name, i.title,
i.url, i.published_at, i.summary, i.author,
i.first_crawl_time, i.last_crawl_time, i.crawl_count
FROM rss_items i
LEFT JOIN rss_feeds f ON i.feed_id = f.id
ORDER BY i.published_at DESC
""")
rows = cursor.fetchall()
for row in rows:
feed_id = row['feed_id']
feed_name = row['feed_name'] or feed_id
title = row['title']
if feed_id not in id_to_name:
id_to_name[feed_id] = feed_name
if feed_id not in all_items:
all_items[feed_id] = {}
all_items[feed_id][title] = {
"url": row['url'] or "",
"published_at": row['published_at'] or "",
"summary": row['summary'] or "",
"author": row['author'] or "",
"first_time": row['first_crawl_time'] or "",
"last_time": row['last_crawl_time'] or "",
"count": row['crawl_count'] or 1,
}
# 获取抓取时间
cursor.execute("""
SELECT crawl_time, created_at FROM rss_crawl_records
ORDER BY crawl_time
""")
for row in cursor.fetchall():
crawl_time = row['crawl_time']
created_at = row['created_at']
try:
ts = datetime.strptime(created_at, "%Y-%m-%d %H:%M:%S").timestamp()
except (ValueError, TypeError):
ts = datetime.now().timestamp()
all_timestamps[f"{crawl_time}.db"] = ts
if not all_items:
return None
return (all_items, id_to_name, all_timestamps)
def read_all_titles_for_date(
self,
date: datetime = None,
platform_ids: Optional[List[str]] = None,
db_type: str = "news"
) -> Tuple[Dict, Dict, Dict]:
date_str = self.get_date_folder_name(date)
platform_key = ','.join(sorted(platform_ids)) if platform_ids else 'all'
cache_key = f"read_all:{db_type}:{date_str}:{platform_key}"
is_today = (date is None) or (date.date() == datetime.now().date())
ttl = 900 if is_today else 900
cached = self.cache.get(cache_key, ttl=ttl)
if cached:
return cached
result = self._read_from_sqlite(date, platform_ids, db_type)
if result:
self.cache.set(cache_key, result)
return result
raise DataNotFoundError(
f"未找到 {date_str} 的 {db_type} 数据",
suggestion="请先运行爬虫或检查日期是否正确"
)
def parse_yaml_config(self, config_path: str = None) -> dict:
if config_path is None:
config_path = self.project_root / "config" / "config.yaml"
else:
config_path = Path(config_path)
if not config_path.exists():
raise FileParseError(str(config_path), "配置文件不存在")
try:
with open(config_path, "r", encoding="utf-8") as f:
config_data = yaml.safe_load(f)
return config_data
except Exception as e:
raise FileParseError(str(config_path), str(e))
def parse_frequency_words(self, words_file: str = None) -> List[Dict]:
import os
from trendradar.core.frequency import load_frequency_words
if words_file is None:
words_file = str(self.project_root / "config" / "frequency_words.txt")
else:
words_file = str(words_file)
try:
current_mtime = os.path.getmtime(words_file)
if self._freq_words_cache is not None and current_mtime == self._freq_words_mtime:
return self._freq_words_cache
word_groups, filter_words, global_filters = load_frequency_words(words_file)
self._freq_words_cache = word_groups
self._freq_words_mtime = current_mtime
return word_groups
except FileNotFoundError:
return []
except Exception as e:
raise FileParseError(words_file, str(e))
def get_available_dates(self, db_type: str = "news") -> List[str]:
db_dir = self.project_root / "output" / db_type
if not db_dir.exists():
return []
dates = []
for db_file in db_dir.glob("*.db"):
date_match = re.match(r'(\d{4}-\d{2}-\d{2})\.db$', db_file.name)
if date_match:
dates.append(date_match.group(1))
return sorted(dates, reverse=True)
def get_available_date_range(self, db_type: str = "news") -> Tuple[Optional[datetime], Optional[datetime]]:
dates = self.get_available_dates(db_type)
if not dates:
return (None, None)
earliest = datetime.strptime(dates[-1], "%Y-%m-%d")
latest = datetime.strptime(dates[0], "%Y-%m-%d")
return (earliest, latest) | --- +++ @@ -1,3 +1,9 @@+"""
+数据解析服务
+
+v2.0.0: 仅支持 SQLite 数据库，移除 TXT 文件支持
+新存储结构：output/{type}/{date}.db
+"""
import re
import sqlite3
@@ -12,8 +18,15 @@
class ParserService:
+ """数据解析服务类"""
def __init__(self, project_root: str = None):
+ """
+ 初始化解析服务
+
+ Args:
+ project_root: 项目根目录，默认为当前目录的父目录
+ """
if project_root is None:
current_file = Path(__file__)
self.project_root = current_file.parent.parent.parent
@@ -28,16 +41,38 @@
@staticmethod
def clean_title(title: str) -> str:
+ """清理标题文本"""
title = re.sub(r'\s+', ' ', title)
title = title.strip()
return title
def get_date_folder_name(self, date: datetime = None) -> str:
+ """
+ 获取日期字符串（ISO 格式）
+
+ Args:
+ date: 日期对象，默认为今天
+
+ Returns:
+ 日期字符串（YYYY-MM-DD）
+ """
if date is None:
date = datetime.now()
return date.strftime("%Y-%m-%d")
def _get_db_path(self, date: datetime = None, db_type: str = "news") -> Optional[Path]:
+ """
+ 获取数据库文件路径
+
+ 新结构：output/{type}/{date}.db
+
+ Args:
+ date: 日期对象，默认为今天
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ 数据库文件路径，如果不存在则返回 None
+ """
date_str = self.get_date_folder_name(date)
db_path = self.project_root / "output" / db_type / f"{date_str}.db"
if db_path.exists():
@@ -50,6 +85,17 @@ platform_ids: Optional[List[str]] = None,
db_type: str = "news"
) -> Optional[Tuple[Dict, Dict, Dict]]:
+ """
+ 从 SQLite 数据库读取数据
+
+ Args:
+ date: 日期对象，默认为今天
+ platform_ids: 平台ID列表，None表示所有平台
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ (all_titles, id_to_name, all_timestamps) 元组，如果数据库不存在返回 None
+ """
db_path = self._get_db_path(date, db_type)
if db_path is None:
return None
@@ -83,6 +129,7 @@ id_to_name: Dict,
all_timestamps: Dict
) -> Optional[Tuple[Dict, Dict, Dict]]:
+ """从热榜数据库读取数据"""
# 检查表是否存在
cursor.execute("""
SELECT name FROM sqlite_master
@@ -183,6 +230,7 @@ id_to_name: Dict,
all_timestamps: Dict
) -> Optional[Tuple[Dict, Dict, Dict]]:
+ """从 RSS 数据库读取数据"""
# 检查表是否存在
cursor.execute("""
SELECT name FROM sqlite_master
@@ -262,6 +310,20 @@ platform_ids: Optional[List[str]] = None,
db_type: str = "news"
) -> Tuple[Dict, Dict, Dict]:
+ """
+ 读取指定日期的所有数据（带缓存）
+
+ Args:
+ date: 日期对象，默认为今天
+ platform_ids: 平台/Feed ID列表，None表示所有
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ (all_titles, id_to_name, all_timestamps) 元组
+
+ Raises:
+ DataNotFoundError: 数据不存在
+ """
date_str = self.get_date_folder_name(date)
platform_key = ','.join(sorted(platform_ids)) if platform_ids else 'all'
cache_key = f"read_all:{db_type}:{date_str}:{platform_key}"
@@ -284,6 +346,18 @@ )
def parse_yaml_config(self, config_path: str = None) -> dict:
+ """
+ 解析YAML配置文件
+
+ Args:
+ config_path: 配置文件路径，默认为 config/config.yaml
+
+ Returns:
+ 配置字典
+
+ Raises:
+ FileParseError: 配置文件解析错误
+ """
if config_path is None:
config_path = self.project_root / "config" / "config.yaml"
else:
@@ -300,6 +374,31 @@ raise FileParseError(str(config_path), str(e))
def parse_frequency_words(self, words_file: str = None) -> List[Dict]:
+ """
+ 解析关键词配置文件（带 mtime 缓存）
+
+ 仅当 frequency_words.txt 被修改时才重新解析，避免循环内重复 IO。
+
+ 复用 trendradar.core.frequency 的解析逻辑，支持：
+ - # 开头的注释行
+ - 空行分隔词组
+ - [组别名] 作为词组第一行，给整组指定别名
+ - +前缀必须词、!前缀过滤词、@数量限制
+ - /pattern/ 正则表达式语法
+ - => 别名 显示名称语法
+ - [GLOBAL_FILTER] 全局过滤区域
+
+ 显示名称优先级：组别名 > 行别名拼接 > 关键词拼接
+
+ Args:
+ words_file: 关键词文件路径，默认为 config/frequency_words.txt
+
+ Returns:
+ 词组列表
+
+ Raises:
+ FileParseError: 文件解析错误
+ """
import os
from trendradar.core.frequency import load_frequency_words
@@ -324,6 +423,15 @@ raise FileParseError(words_file, str(e))
def get_available_dates(self, db_type: str = "news") -> List[str]:
+ """
+ 获取可用的日期列表
+
+ Args:
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ 日期字符串列表（YYYY-MM-DD 格式，降序排列）
+ """
db_dir = self.project_root / "output" / db_type
if not db_dir.exists():
return []
@@ -337,10 +445,19 @@ return sorted(dates, reverse=True)
def get_available_date_range(self, db_type: str = "news") -> Tuple[Optional[datetime], Optional[datetime]]:
+ """
+ 获取可用的日期范围
+
+ Args:
+ db_type: 数据库类型 ("news" 或 "rss")
+
+ Returns:
+ (最早日期, 最新日期) 元组，如果没有数据则返回 (None, None)
+ """
dates = self.get_available_dates(db_type)
if not dates:
return (None, None)
earliest = datetime.strptime(dates[-1], "%Y-%m-%d")
latest = datetime.strptime(dates[0], "%Y-%m-%d")
- return (earliest, latest)+ return (earliest, latest)
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/services/parser_service.py |
Add standardized docstrings across the file | import datetime
import logging
import os
import pandas as pd
import requests
import time
logger = logging.getLogger(__name__)
from src.data.cache import get_cache
from src.data.models import (
CompanyNews,
CompanyNewsResponse,
FinancialMetrics,
FinancialMetricsResponse,
Price,
PriceResponse,
LineItem,
LineItemResponse,
InsiderTrade,
InsiderTradeResponse,
CompanyFactsResponse,
)
# Global cache instance
_cache = get_cache()
def _make_api_request(url: str, headers: dict, method: str = "GET", json_data: dict = None, max_retries: int = 3) -> requests.Response:
for attempt in range(max_retries + 1): # +1 for initial attempt
if method.upper() == "POST":
response = requests.post(url, headers=headers, json=json_data)
else:
response = requests.get(url, headers=headers)
if response.status_code == 429 and attempt < max_retries:
# Linear backoff: 60s, 90s, 120s, 150s...
delay = 60 + (30 * attempt)
print(f"Rate limited (429). Attempt {attempt + 1}/{max_retries + 1}. Waiting {delay}s before retrying...")
time.sleep(delay)
continue
# Return the response (whether success, other errors, or final 429)
return response
def get_prices(ticker: str, start_date: str, end_date: str, api_key: str = None) -> list[Price]:
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date}_{end_date}"
# Check cache first - simple exact match
if cached_data := _cache.get_prices(cache_key):
return [Price(**price) for price in cached_data]
# If not in cache, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
url = f"https://api.financialdatasets.ai/prices/?ticker={ticker}&interval=day&interval_multiplier=1&start_date={start_date}&end_date={end_date}"
response = _make_api_request(url, headers)
if response.status_code != 200:
return []
# Parse response with Pydantic model
try:
price_response = PriceResponse(**response.json())
prices = price_response.prices
except Exception as e:
logger.warning("Failed to parse price response for %s: %s", ticker, e)
return []
if not prices:
return []
# Cache the results using the comprehensive cache key
_cache.set_prices(cache_key, [p.model_dump() for p in prices])
return prices
def get_financial_metrics(
ticker: str,
end_date: str,
period: str = "ttm",
limit: int = 10,
api_key: str = None,
) -> list[FinancialMetrics]:
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{period}_{end_date}_{limit}"
# Check cache first - simple exact match
if cached_data := _cache.get_financial_metrics(cache_key):
return [FinancialMetrics(**metric) for metric in cached_data]
# If not in cache, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
url = f"https://api.financialdatasets.ai/financial-metrics/?ticker={ticker}&report_period_lte={end_date}&limit={limit}&period={period}"
response = _make_api_request(url, headers)
if response.status_code != 200:
return []
# Parse response with Pydantic model
try:
metrics_response = FinancialMetricsResponse(**response.json())
financial_metrics = metrics_response.financial_metrics
except Exception as e:
logger.warning("Failed to parse financial metrics response for %s: %s", ticker, e)
return []
if not financial_metrics:
return []
# Cache the results as dicts using the comprehensive cache key
_cache.set_financial_metrics(cache_key, [m.model_dump() for m in financial_metrics])
return financial_metrics
def search_line_items(
ticker: str,
line_items: list[str],
end_date: str,
period: str = "ttm",
limit: int = 10,
api_key: str = None,
) -> list[LineItem]:
# If not in cache or insufficient data, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
url = "https://api.financialdatasets.ai/financials/search/line-items"
body = {
"tickers": [ticker],
"line_items": line_items,
"end_date": end_date,
"period": period,
"limit": limit,
}
response = _make_api_request(url, headers, method="POST", json_data=body)
if response.status_code != 200:
return []
try:
data = response.json()
response_model = LineItemResponse(**data)
search_results = response_model.search_results
except Exception as e:
logger.warning("Failed to parse line items response for %s: %s", ticker, e)
return []
if not search_results:
return []
# Cache the results
return search_results[:limit]
def get_insider_trades(
ticker: str,
end_date: str,
start_date: str | None = None,
limit: int = 1000,
api_key: str = None,
) -> list[InsiderTrade]:
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
# Check cache first - simple exact match
if cached_data := _cache.get_insider_trades(cache_key):
return [InsiderTrade(**trade) for trade in cached_data]
# If not in cache, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
all_trades = []
current_end_date = end_date
while True:
url = f"https://api.financialdatasets.ai/insider-trades/?ticker={ticker}&filing_date_lte={current_end_date}"
if start_date:
url += f"&filing_date_gte={start_date}"
url += f"&limit={limit}"
response = _make_api_request(url, headers)
if response.status_code != 200:
break
try:
data = response.json()
response_model = InsiderTradeResponse(**data)
insider_trades = response_model.insider_trades
except Exception as e:
logger.warning("Failed to parse insider trades response for %s: %s", ticker, e)
break
if not insider_trades:
break
all_trades.extend(insider_trades)
# Only continue pagination if we have a start_date and got a full page
if not start_date or len(insider_trades) < limit:
break
# Update end_date to the oldest filing date from current batch for next iteration
current_end_date = min(trade.filing_date for trade in insider_trades).split("T")[0]
# If we've reached or passed the start_date, we can stop
if current_end_date <= start_date:
break
if not all_trades:
return []
# Cache the results using the comprehensive cache key
_cache.set_insider_trades(cache_key, [trade.model_dump() for trade in all_trades])
return all_trades
def get_company_news(
ticker: str,
end_date: str,
start_date: str | None = None,
limit: int = 1000,
api_key: str = None,
) -> list[CompanyNews]:
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
# Check cache first - simple exact match
if cached_data := _cache.get_company_news(cache_key):
return [CompanyNews(**news) for news in cached_data]
# If not in cache, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
all_news = []
current_end_date = end_date
while True:
url = f"https://api.financialdatasets.ai/news/?ticker={ticker}&end_date={current_end_date}"
if start_date:
url += f"&start_date={start_date}"
url += f"&limit={limit}"
response = _make_api_request(url, headers)
if response.status_code != 200:
break
try:
data = response.json()
response_model = CompanyNewsResponse(**data)
company_news = response_model.news
except Exception as e:
logger.warning("Failed to parse company news response for %s: %s", ticker, e)
break
if not company_news:
break
all_news.extend(company_news)
# Only continue pagination if we have a start_date and got a full page
if not start_date or len(company_news) < limit:
break
# Update end_date to the oldest date from current batch for next iteration
current_end_date = min(news.date for news in company_news).split("T")[0]
# If we've reached or passed the start_date, we can stop
if current_end_date <= start_date:
break
if not all_news:
return []
# Cache the results using the comprehensive cache key
_cache.set_company_news(cache_key, [news.model_dump() for news in all_news])
return all_news
def get_market_cap(
ticker: str,
end_date: str,
api_key: str = None,
) -> float | None:
# Check if end_date is today
if end_date == datetime.datetime.now().strftime("%Y-%m-%d"):
# Get the market cap from company facts API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
if financial_api_key:
headers["X-API-KEY"] = financial_api_key
url = f"https://api.financialdatasets.ai/company/facts/?ticker={ticker}"
response = _make_api_request(url, headers)
if response.status_code != 200:
print(f"Error fetching company facts: {ticker} - {response.status_code}")
return None
data = response.json()
response_model = CompanyFactsResponse(**data)
return response_model.company_facts.market_cap
financial_metrics = get_financial_metrics(ticker, end_date, api_key=api_key)
if not financial_metrics:
return None
market_cap = financial_metrics[0].market_cap
if not market_cap:
return None
return market_cap
def prices_to_df(prices: list[Price]) -> pd.DataFrame:
df = pd.DataFrame([p.model_dump() for p in prices])
df["Date"] = pd.to_datetime(df["time"])
df.set_index("Date", inplace=True)
numeric_cols = ["open", "close", "high", "low", "volume"]
for col in numeric_cols:
df[col] = pd.to_numeric(df[col], errors="coerce")
df.sort_index(inplace=True)
return df
# Update the get_price_data function to use the new functions
def get_price_data(ticker: str, start_date: str, end_date: str, api_key: str = None) -> pd.DataFrame:
prices = get_prices(ticker, start_date, end_date, api_key=api_key)
return prices_to_df(prices) | --- +++ @@ -27,6 +27,22 @@
def _make_api_request(url: str, headers: dict, method: str = "GET", json_data: dict = None, max_retries: int = 3) -> requests.Response:
+ """
+ Make an API request with rate limiting handling and moderate backoff.
+
+ Args:
+ url: The URL to request
+ headers: Headers to include in the request
+ method: HTTP method (GET or POST)
+ json_data: JSON data for POST requests
+ max_retries: Maximum number of retries (default: 3)
+
+ Returns:
+ requests.Response: The response object
+
+ Raises:
+ Exception: If the request fails with a non-429 error
+ """
for attempt in range(max_retries + 1): # +1 for initial attempt
if method.upper() == "POST":
response = requests.post(url, headers=headers, json=json_data)
@@ -45,6 +61,7 @@
def get_prices(ticker: str, start_date: str, end_date: str, api_key: str = None) -> list[Price]:
+ """Fetch price data from cache or API."""
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date}_{end_date}"
@@ -86,6 +103,7 @@ limit: int = 10,
api_key: str = None,
) -> list[FinancialMetrics]:
+ """Fetch financial metrics from cache or API."""
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{period}_{end_date}_{limit}"
@@ -128,6 +146,7 @@ limit: int = 10,
api_key: str = None,
) -> list[LineItem]:
+ """Fetch line items from API."""
# If not in cache or insufficient data, fetch from API
headers = {}
financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
@@ -168,6 +187,7 @@ limit: int = 1000,
api_key: str = None,
) -> list[InsiderTrade]:
+ """Fetch insider trades from cache or API."""
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
@@ -233,6 +253,7 @@ limit: int = 1000,
api_key: str = None,
) -> list[CompanyNews]:
+ """Fetch company news from cache or API."""
# Create a cache key that includes all parameters to ensure exact matches
cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
@@ -296,6 +317,7 @@ end_date: str,
api_key: str = None,
) -> float | None:
+ """Fetch market cap from the API."""
# Check if end_date is today
if end_date == datetime.datetime.now().strftime("%Y-%m-%d"):
# Get the market cap from company facts API
@@ -327,6 +349,7 @@
def prices_to_df(prices: list[Price]) -> pd.DataFrame:
+ """Convert prices to a DataFrame."""
df = pd.DataFrame([p.model_dump() for p in prices])
df["Date"] = pd.to_datetime(df["time"])
df.set_index("Date", inplace=True)
@@ -340,4 +363,4 @@ # Update the get_price_data function to use the new functions
def get_price_data(ticker: str, start_date: str, end_date: str, api_key: str = None) -> pd.DataFrame:
prices = get_prices(ticker, start_date, end_date, api_key=api_key)
- return prices_to_df(prices)+ return prices_to_df(prices)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/tools/api.py |
Generate docstrings with parameter types | import os
import json
from langchain_anthropic import ChatAnthropic
from langchain_deepseek import ChatDeepSeek
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_groq import ChatGroq
from langchain_xai import ChatXAI
from langchain_openai import ChatOpenAI, AzureChatOpenAI
from langchain_gigachat import GigaChat
from langchain_ollama import ChatOllama
from enum import Enum
from pydantic import BaseModel
from typing import Tuple, List
from pathlib import Path
class ModelProvider(str, Enum):
ALIBABA = "Alibaba"
ANTHROPIC = "Anthropic"
DEEPSEEK = "DeepSeek"
GOOGLE = "Google"
GROQ = "Groq"
META = "Meta"
MISTRAL = "Mistral"
OPENAI = "OpenAI"
OLLAMA = "Ollama"
OPENROUTER = "OpenRouter"
GIGACHAT = "GigaChat"
AZURE_OPENAI = "Azure OpenAI"
XAI = "xAI"
class LLMModel(BaseModel):
display_name: str
model_name: str
provider: ModelProvider
def to_choice_tuple(self) -> Tuple[str, str, str]:
return (self.display_name, self.model_name, self.provider.value)
def is_custom(self) -> bool:
return self.model_name == "-"
def has_json_mode(self) -> bool:
if self.is_deepseek() or self.is_gemini():
return False
# Only certain Ollama models support JSON mode
if self.is_ollama():
return "llama3" in self.model_name or "neural-chat" in self.model_name
# OpenRouter models generally support JSON mode
if self.provider == ModelProvider.OPENROUTER:
return True
return True
def is_deepseek(self) -> bool:
return self.model_name.startswith("deepseek")
def is_gemini(self) -> bool:
return self.model_name.startswith("gemini")
def is_ollama(self) -> bool:
return self.provider == ModelProvider.OLLAMA
# Load models from JSON file
def load_models_from_json(json_path: str) -> List[LLMModel]:
with open(json_path, 'r') as f:
models_data = json.load(f)
models = []
for model_data in models_data:
# Convert string provider to ModelProvider enum
provider_enum = ModelProvider(model_data["provider"])
models.append(
LLMModel(
display_name=model_data["display_name"],
model_name=model_data["model_name"],
provider=provider_enum
)
)
return models
# Get the path to the JSON files
current_dir = Path(__file__).parent
models_json_path = current_dir / "api_models.json"
ollama_models_json_path = current_dir / "ollama_models.json"
# Load available models from JSON
AVAILABLE_MODELS = load_models_from_json(str(models_json_path))
# Load Ollama models from JSON
OLLAMA_MODELS = load_models_from_json(str(ollama_models_json_path))
# Create LLM_ORDER in the format expected by the UI
LLM_ORDER = [model.to_choice_tuple() for model in AVAILABLE_MODELS]
# Create Ollama LLM_ORDER separately
OLLAMA_LLM_ORDER = [model.to_choice_tuple() for model in OLLAMA_MODELS]
def get_model_info(model_name: str, model_provider: str) -> LLMModel | None:
all_models = AVAILABLE_MODELS + OLLAMA_MODELS
return next((model for model in all_models if model.model_name == model_name and model.provider == model_provider), None)
def find_model_by_name(model_name: str) -> LLMModel | None:
all_models = AVAILABLE_MODELS + OLLAMA_MODELS
return next((model for model in all_models if model.model_name == model_name), None)
def get_models_list():
return [
{
"display_name": model.display_name,
"model_name": model.model_name,
"provider": model.provider.value
}
for model in AVAILABLE_MODELS
]
def get_model(model_name: str, model_provider: ModelProvider, api_keys: dict = None) -> ChatOpenAI | ChatGroq | ChatOllama | GigaChat | None:
if model_provider == ModelProvider.GROQ:
api_key = (api_keys or {}).get("GROQ_API_KEY") or os.getenv("GROQ_API_KEY")
if not api_key:
# Print error to console
print(f"API Key Error: Please make sure GROQ_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("Groq API key not found. Please make sure GROQ_API_KEY is set in your .env file or provided via API keys.")
return ChatGroq(model=model_name, api_key=api_key)
elif model_provider == ModelProvider.OPENAI:
# Get and validate API key
api_key = (api_keys or {}).get("OPENAI_API_KEY") or os.getenv("OPENAI_API_KEY")
base_url = os.getenv("OPENAI_API_BASE")
if not api_key:
# Print error to console
print(f"API Key Error: Please make sure OPENAI_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("OpenAI API key not found. Please make sure OPENAI_API_KEY is set in your .env file or provided via API keys.")
return ChatOpenAI(model=model_name, api_key=api_key, base_url=base_url)
elif model_provider == ModelProvider.ANTHROPIC:
api_key = (api_keys or {}).get("ANTHROPIC_API_KEY") or os.getenv("ANTHROPIC_API_KEY")
if not api_key:
print(f"API Key Error: Please make sure ANTHROPIC_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("Anthropic API key not found. Please make sure ANTHROPIC_API_KEY is set in your .env file or provided via API keys.")
return ChatAnthropic(model=model_name, api_key=api_key)
elif model_provider == ModelProvider.DEEPSEEK:
api_key = (api_keys or {}).get("DEEPSEEK_API_KEY") or os.getenv("DEEPSEEK_API_KEY")
if not api_key:
print(f"API Key Error: Please make sure DEEPSEEK_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("DeepSeek API key not found. Please make sure DEEPSEEK_API_KEY is set in your .env file or provided via API keys.")
return ChatDeepSeek(model=model_name, api_key=api_key)
elif model_provider == ModelProvider.GOOGLE:
api_key = (api_keys or {}).get("GOOGLE_API_KEY") or os.getenv("GOOGLE_API_KEY")
if not api_key:
print(f"API Key Error: Please make sure GOOGLE_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("Google API key not found. Please make sure GOOGLE_API_KEY is set in your .env file or provided via API keys.")
return ChatGoogleGenerativeAI(model=model_name, api_key=api_key)
elif model_provider == ModelProvider.OLLAMA:
# For Ollama, we use a base URL instead of an API key
# Check if OLLAMA_HOST is set (for Docker on macOS)
ollama_host = os.getenv("OLLAMA_HOST", "localhost")
base_url = os.getenv("OLLAMA_BASE_URL", f"http://{ollama_host}:11434")
return ChatOllama(
model=model_name,
base_url=base_url,
)
elif model_provider == ModelProvider.OPENROUTER:
api_key = (api_keys or {}).get("OPENROUTER_API_KEY") or os.getenv("OPENROUTER_API_KEY")
if not api_key:
print(f"API Key Error: Please make sure OPENROUTER_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("OpenRouter API key not found. Please make sure OPENROUTER_API_KEY is set in your .env file or provided via API keys.")
# Get optional site URL and name for headers
site_url = os.getenv("YOUR_SITE_URL", "https://github.com/virattt/ai-hedge-fund")
site_name = os.getenv("YOUR_SITE_NAME", "AI Hedge Fund")
return ChatOpenAI(
model=model_name,
openai_api_key=api_key,
openai_api_base="https://openrouter.ai/api/v1",
model_kwargs={
"extra_headers": {
"HTTP-Referer": site_url,
"X-Title": site_name,
}
}
)
elif model_provider == ModelProvider.XAI:
api_key = (api_keys or {}).get("XAI_API_KEY") or os.getenv("XAI_API_KEY")
if not api_key:
print(f"API Key Error: Please make sure XAI_API_KEY is set in your .env file or provided via API keys.")
raise ValueError("xAI API key not found. Please make sure XAI_API_KEY is set in your .env file or provided via API keys.")
return ChatXAI(model=model_name, api_key=api_key)
elif model_provider == ModelProvider.GIGACHAT:
if os.getenv("GIGACHAT_USER") or os.getenv("GIGACHAT_PASSWORD"):
return GigaChat(model=model_name)
else:
api_key = (api_keys or {}).get("GIGACHAT_API_KEY") or os.getenv("GIGACHAT_API_KEY") or os.getenv("GIGACHAT_CREDENTIALS")
if not api_key:
print("API Key Error: Please make sure api_keys is set in your .env file or provided via API keys.")
raise ValueError("GigaChat API key not found. Please make sure GIGACHAT_API_KEY is set in your .env file or provided via API keys.")
return GigaChat(credentials=api_key, model=model_name)
elif model_provider == ModelProvider.AZURE_OPENAI:
# Get and validate API key
api_key = os.getenv("AZURE_OPENAI_API_KEY")
if not api_key:
# Print error to console
print(f"API Key Error: Please make sure AZURE_OPENAI_API_KEY is set in your .env file.")
raise ValueError("Azure OpenAI API key not found. Please make sure AZURE_OPENAI_API_KEY is set in your .env file.")
# Get and validate Azure Endpoint
azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not azure_endpoint:
# Print error to console
print(f"Azure Endpoint Error: Please make sure AZURE_OPENAI_ENDPOINT is set in your .env file.")
raise ValueError("Azure OpenAI endpoint not found. Please make sure AZURE_OPENAI_ENDPOINT is set in your .env file.")
# get and validate deployment name
azure_deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
if not azure_deployment_name:
# Print error to console
print(f"Azure Deployment Name Error: Please make sure AZURE_OPENAI_DEPLOYMENT_NAME is set in your .env file.")
raise ValueError("Azure OpenAI deployment name not found. Please make sure AZURE_OPENAI_DEPLOYMENT_NAME is set in your .env file.")
return AzureChatOpenAI(azure_endpoint=azure_endpoint, azure_deployment=azure_deployment_name, api_key=api_key, api_version="2024-10-21")
else:
raise ValueError(
f"Unsupported model provider: {model_provider}. "
f"Supported providers: {', '.join(p.value for p in ModelProvider)}"
) | --- +++ @@ -15,6 +15,7 @@
class ModelProvider(str, Enum):
+ """Enum for supported LLM providers"""
ALIBABA = "Alibaba"
ANTHROPIC = "Anthropic"
@@ -32,18 +33,22 @@
class LLMModel(BaseModel):
+ """Represents an LLM model configuration"""
display_name: str
model_name: str
provider: ModelProvider
def to_choice_tuple(self) -> Tuple[str, str, str]:
+ """Convert to format needed for questionary choices"""
return (self.display_name, self.model_name, self.provider.value)
def is_custom(self) -> bool:
+ """Check if the model is a Gemini model"""
return self.model_name == "-"
def has_json_mode(self) -> bool:
+ """Check if the model supports JSON mode"""
if self.is_deepseek() or self.is_gemini():
return False
# Only certain Ollama models support JSON mode
@@ -55,17 +60,21 @@ return True
def is_deepseek(self) -> bool:
+ """Check if the model is a DeepSeek model"""
return self.model_name.startswith("deepseek")
def is_gemini(self) -> bool:
+ """Check if the model is a Gemini model"""
return self.model_name.startswith("gemini")
def is_ollama(self) -> bool:
+ """Check if the model is an Ollama model"""
return self.provider == ModelProvider.OLLAMA
# Load models from JSON file
def load_models_from_json(json_path: str) -> List[LLMModel]:
+ """Load models from a JSON file"""
with open(json_path, 'r') as f:
models_data = json.load(f)
@@ -102,16 +111,19 @@
def get_model_info(model_name: str, model_provider: str) -> LLMModel | None:
+ """Get model information by model_name"""
all_models = AVAILABLE_MODELS + OLLAMA_MODELS
return next((model for model in all_models if model.model_name == model_name and model.provider == model_provider), None)
def find_model_by_name(model_name: str) -> LLMModel | None:
+ """Find a model by its name across all available models."""
all_models = AVAILABLE_MODELS + OLLAMA_MODELS
return next((model for model in all_models if model.model_name == model_name), None)
def get_models_list():
+ """Get the list of models for API responses."""
return [
{
"display_name": model.display_name,
@@ -227,4 +239,4 @@ raise ValueError(
f"Unsupported model provider: {model_provider}. "
f"Supported providers: {', '.join(p.value for p in ModelProvider)}"
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/llm/models.py |
Create docstrings for all classes and functions | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import (
get_market_cap,
search_line_items,
get_insider_trades,
get_company_news,
)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
import statistics
from src.utils.api_key import get_api_key_from_state
class PhilFisherSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def phil_fisher_agent(state: AgentState, agent_id: str = "phil_fisher_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
fisher_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Gathering financial line items")
# Include relevant line items for Phil Fisher's approach:
# - Growth & Quality: revenue, net_income, earnings_per_share, R&D expense
# - Margins & Stability: operating_income, operating_margin, gross_margin
# - Management Efficiency & Leverage: total_debt, shareholders_equity, free_cash_flow
# - Valuation: net_income, free_cash_flow (for P/E, P/FCF), ebit, ebitda
financial_line_items = search_line_items(
ticker,
[
"revenue",
"net_income",
"earnings_per_share",
"free_cash_flow",
"research_and_development",
"operating_income",
"operating_margin",
"gross_margin",
"total_debt",
"shareholders_equity",
"cash_and_equivalents",
"ebit",
"ebitda",
],
end_date,
period="annual",
limit=5,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching insider trades")
insider_trades = get_insider_trades(ticker, end_date, limit=50, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching company news")
company_news = get_company_news(ticker, end_date, limit=50, api_key=api_key)
progress.update_status(agent_id, ticker, "Analyzing growth & quality")
growth_quality = analyze_fisher_growth_quality(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing margins & stability")
margins_stability = analyze_margins_stability(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing management efficiency & leverage")
mgmt_efficiency = analyze_management_efficiency_leverage(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing valuation (Fisher style)")
fisher_valuation = analyze_fisher_valuation(financial_line_items, market_cap)
progress.update_status(agent_id, ticker, "Analyzing insider activity")
insider_activity = analyze_insider_activity(insider_trades)
progress.update_status(agent_id, ticker, "Analyzing sentiment")
sentiment_analysis = analyze_sentiment(company_news)
# Combine partial scores with weights typical for Fisher:
# 30% Growth & Quality
# 25% Margins & Stability
# 20% Management Efficiency
# 15% Valuation
# 5% Insider Activity
# 5% Sentiment
total_score = (
growth_quality["score"] * 0.30
+ margins_stability["score"] * 0.25
+ mgmt_efficiency["score"] * 0.20
+ fisher_valuation["score"] * 0.15
+ insider_activity["score"] * 0.05
+ sentiment_analysis["score"] * 0.05
)
max_possible_score = 10
# Simple bullish/neutral/bearish signal
if total_score >= 7.5:
signal = "bullish"
elif total_score <= 4.5:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_possible_score,
"growth_quality": growth_quality,
"margins_stability": margins_stability,
"management_efficiency": mgmt_efficiency,
"valuation_analysis": fisher_valuation,
"insider_activity": insider_activity,
"sentiment_analysis": sentiment_analysis,
}
progress.update_status(agent_id, ticker, "Generating Phil Fisher-style analysis")
fisher_output = generate_fisher_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
fisher_analysis[ticker] = {
"signal": fisher_output.signal,
"confidence": fisher_output.confidence,
"reasoning": fisher_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=fisher_output.reasoning)
# Wrap results in a single message
message = HumanMessage(content=json.dumps(fisher_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(fisher_analysis, "Phil Fisher Agent")
state["data"]["analyst_signals"][agent_id] = fisher_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_fisher_growth_quality(financial_line_items: list) -> dict:
if not financial_line_items or len(financial_line_items) < 2:
return {
"score": 0,
"details": "Insufficient financial data for growth/quality analysis",
}
details = []
raw_score = 0 # up to 9 raw points => scale to 0–10
# 1. Revenue Growth (annualized CAGR)
revenues = [fi.revenue for fi in financial_line_items if fi.revenue is not None]
if len(revenues) >= 2:
# Calculate annualized growth rate (CAGR) for proper comparison
latest_rev = revenues[0]
oldest_rev = revenues[-1]
num_years = len(revenues) - 1
if oldest_rev > 0 and latest_rev > 0:
# CAGR formula: (ending_value/beginning_value)^(1/years) - 1
rev_growth = (latest_rev / oldest_rev) ** (1 / num_years) - 1
if rev_growth > 0.20: # 20% annualized
raw_score += 3
details.append(f"Very strong annualized revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.10: # 10% annualized
raw_score += 2
details.append(f"Moderate annualized revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.03: # 3% annualized
raw_score += 1
details.append(f"Slight annualized revenue growth: {rev_growth:.1%}")
else:
details.append(f"Minimal or negative annualized revenue growth: {rev_growth:.1%}")
else:
details.append("Oldest revenue is zero/negative; cannot compute growth.")
else:
details.append("Not enough revenue data points for growth calculation.")
# 2. EPS Growth (annualized CAGR)
eps_values = [fi.earnings_per_share for fi in financial_line_items if fi.earnings_per_share is not None]
if len(eps_values) >= 2:
latest_eps = eps_values[0]
oldest_eps = eps_values[-1]
num_years = len(eps_values) - 1
if oldest_eps > 0 and latest_eps > 0:
# CAGR formula for EPS
eps_growth = (latest_eps / oldest_eps) ** (1 / num_years) - 1
if eps_growth > 0.20: # 20% annualized
raw_score += 3
details.append(f"Very strong annualized EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.10: # 10% annualized
raw_score += 2
details.append(f"Moderate annualized EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.03: # 3% annualized
raw_score += 1
details.append(f"Slight annualized EPS growth: {eps_growth:.1%}")
else:
details.append(f"Minimal or negative annualized EPS growth: {eps_growth:.1%}")
else:
details.append("Oldest EPS near zero; skipping EPS growth calculation.")
else:
details.append("Not enough EPS data points for growth calculation.")
# 3. R&D as % of Revenue (if we have R&D data)
rnd_values = [fi.research_and_development for fi in financial_line_items if fi.research_and_development is not None]
if rnd_values and revenues and len(rnd_values) == len(revenues):
# We'll just look at the most recent for a simple measure
recent_rnd = rnd_values[0]
recent_rev = revenues[0] if revenues[0] else 1e-9
rnd_ratio = recent_rnd / recent_rev
# Generally, Fisher admired companies that invest aggressively in R&D,
# but it must be appropriate. We'll assume "3%-15%" is healthy, just as an example.
if 0.03 <= rnd_ratio <= 0.15:
raw_score += 3
details.append(f"R&D ratio {rnd_ratio:.1%} indicates significant investment in future growth")
elif rnd_ratio > 0.15:
raw_score += 2
details.append(f"R&D ratio {rnd_ratio:.1%} is very high (could be good if well-managed)")
elif rnd_ratio > 0.0:
raw_score += 1
details.append(f"R&D ratio {rnd_ratio:.1%} is somewhat low but still positive")
else:
details.append("No meaningful R&D expense ratio")
else:
details.append("Insufficient R&D data to evaluate")
# scale raw_score (max 9) to 0–10
final_score = min(10, (raw_score / 9) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_margins_stability(financial_line_items: list) -> dict:
if not financial_line_items or len(financial_line_items) < 2:
return {
"score": 0,
"details": "Insufficient data for margin stability analysis",
}
details = []
raw_score = 0 # up to 6 => scale to 0-10
# 1. Operating Margin Consistency
op_margins = [fi.operating_margin for fi in financial_line_items if fi.operating_margin is not None]
if len(op_margins) >= 2:
# Check if margins are stable or improving (comparing oldest to newest)
oldest_op_margin = op_margins[-1]
newest_op_margin = op_margins[0]
if newest_op_margin >= oldest_op_margin > 0:
raw_score += 2
details.append(f"Operating margin stable or improving ({oldest_op_margin:.1%} -> {newest_op_margin:.1%})")
elif newest_op_margin > 0:
raw_score += 1
details.append(f"Operating margin positive but slightly declined")
else:
details.append(f"Operating margin may be negative or uncertain")
else:
details.append("Not enough operating margin data points")
# 2. Gross Margin Level
gm_values = [fi.gross_margin for fi in financial_line_items if fi.gross_margin is not None]
if gm_values:
# We'll just take the most recent
recent_gm = gm_values[0]
if recent_gm > 0.5:
raw_score += 2
details.append(f"Strong gross margin: {recent_gm:.1%}")
elif recent_gm > 0.3:
raw_score += 1
details.append(f"Moderate gross margin: {recent_gm:.1%}")
else:
details.append(f"Low gross margin: {recent_gm:.1%}")
else:
details.append("No gross margin data available")
# 3. Multi-year Margin Stability
# e.g. if we have at least 3 data points, see if standard deviation is low.
if len(op_margins) >= 3:
stdev = statistics.pstdev(op_margins)
if stdev < 0.02:
raw_score += 2
details.append("Operating margin extremely stable over multiple years")
elif stdev < 0.05:
raw_score += 1
details.append("Operating margin reasonably stable")
else:
details.append("Operating margin volatility is high")
else:
details.append("Not enough margin data points for volatility check")
# scale raw_score (max 6) to 0-10
final_score = min(10, (raw_score / 6) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_management_efficiency_leverage(financial_line_items: list) -> dict:
if not financial_line_items:
return {
"score": 0,
"details": "No financial data for management efficiency analysis",
}
details = []
raw_score = 0 # up to 6 => scale to 0–10
# 1. Return on Equity (ROE)
ni_values = [fi.net_income for fi in financial_line_items if fi.net_income is not None]
eq_values = [fi.shareholders_equity for fi in financial_line_items if fi.shareholders_equity is not None]
if ni_values and eq_values and len(ni_values) == len(eq_values):
recent_ni = ni_values[0]
recent_eq = eq_values[0] if eq_values[0] else 1e-9
if recent_ni > 0:
roe = recent_ni / recent_eq
if roe > 0.2:
raw_score += 3
details.append(f"High ROE: {roe:.1%}")
elif roe > 0.1:
raw_score += 2
details.append(f"Moderate ROE: {roe:.1%}")
elif roe > 0:
raw_score += 1
details.append(f"Positive but low ROE: {roe:.1%}")
else:
details.append(f"ROE is near zero or negative: {roe:.1%}")
else:
details.append("Recent net income is zero or negative, hurting ROE")
else:
details.append("Insufficient data for ROE calculation")
# 2. Debt-to-Equity
debt_values = [fi.total_debt for fi in financial_line_items if fi.total_debt is not None]
if debt_values and eq_values and len(debt_values) == len(eq_values):
recent_debt = debt_values[0]
recent_equity = eq_values[0] if eq_values[0] else 1e-9
dte = recent_debt / recent_equity
if dte < 0.3:
raw_score += 2
details.append(f"Low debt-to-equity: {dte:.2f}")
elif dte < 1.0:
raw_score += 1
details.append(f"Manageable debt-to-equity: {dte:.2f}")
else:
details.append(f"High debt-to-equity: {dte:.2f}")
else:
details.append("Insufficient data for debt/equity analysis")
# 3. FCF Consistency
fcf_values = [fi.free_cash_flow for fi in financial_line_items if fi.free_cash_flow is not None]
if fcf_values and len(fcf_values) >= 2:
# Check if FCF is positive in recent years
positive_fcf_count = sum(1 for x in fcf_values if x and x > 0)
# We'll be simplistic: if most are positive, reward
ratio = positive_fcf_count / len(fcf_values)
if ratio > 0.8:
raw_score += 1
details.append(f"Majority of periods have positive FCF ({positive_fcf_count}/{len(fcf_values)})")
else:
details.append(f"Free cash flow is inconsistent or often negative")
else:
details.append("Insufficient or no FCF data to check consistency")
final_score = min(10, (raw_score / 6) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_fisher_valuation(financial_line_items: list, market_cap: float | None) -> dict:
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data to perform valuation"}
details = []
raw_score = 0
# Gather needed data
net_incomes = [fi.net_income for fi in financial_line_items if fi.net_income is not None]
fcf_values = [fi.free_cash_flow for fi in financial_line_items if fi.free_cash_flow is not None]
# 1) P/E
recent_net_income = net_incomes[0] if net_incomes else None
if recent_net_income and recent_net_income > 0:
pe = market_cap / recent_net_income
pe_points = 0
if pe < 20:
pe_points = 2
details.append(f"Reasonably attractive P/E: {pe:.2f}")
elif pe < 30:
pe_points = 1
details.append(f"Somewhat high but possibly justifiable P/E: {pe:.2f}")
else:
details.append(f"Very high P/E: {pe:.2f}")
raw_score += pe_points
else:
details.append("No positive net income for P/E calculation")
# 2) P/FCF
recent_fcf = fcf_values[0] if fcf_values else None
if recent_fcf and recent_fcf > 0:
pfcf = market_cap / recent_fcf
pfcf_points = 0
if pfcf < 20:
pfcf_points = 2
details.append(f"Reasonable P/FCF: {pfcf:.2f}")
elif pfcf < 30:
pfcf_points = 1
details.append(f"Somewhat high P/FCF: {pfcf:.2f}")
else:
details.append(f"Excessively high P/FCF: {pfcf:.2f}")
raw_score += pfcf_points
else:
details.append("No positive free cash flow for P/FCF calculation")
# scale raw_score (max 4) to 0–10
final_score = min(10, (raw_score / 4) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_insider_activity(insider_trades: list) -> dict:
# Default is neutral (5/10).
score = 5
details = []
if not insider_trades:
details.append("No insider trades data; defaulting to neutral")
return {"score": score, "details": "; ".join(details)}
buys, sells = 0, 0
for trade in insider_trades:
if trade.transaction_shares is not None:
if trade.transaction_shares > 0:
buys += 1
elif trade.transaction_shares < 0:
sells += 1
total = buys + sells
if total == 0:
details.append("No buy/sell transactions found; neutral")
return {"score": score, "details": "; ".join(details)}
buy_ratio = buys / total
if buy_ratio > 0.7:
score = 8
details.append(f"Heavy insider buying: {buys} buys vs. {sells} sells")
elif buy_ratio > 0.4:
score = 6
details.append(f"Moderate insider buying: {buys} buys vs. {sells} sells")
else:
score = 4
details.append(f"Mostly insider selling: {buys} buys vs. {sells} sells")
return {"score": score, "details": "; ".join(details)}
def analyze_sentiment(news_items: list) -> dict:
if not news_items:
return {"score": 5, "details": "No news data; defaulting to neutral sentiment"}
negative_keywords = ["lawsuit", "fraud", "negative", "downturn", "decline", "investigation", "recall"]
negative_count = 0
for news in news_items:
title_lower = (news.title or "").lower()
if any(word in title_lower for word in negative_keywords):
negative_count += 1
details = []
if negative_count > len(news_items) * 0.3:
score = 3
details.append(f"High proportion of negative headlines: {negative_count}/{len(news_items)}")
elif negative_count > 0:
score = 6
details.append(f"Some negative headlines: {negative_count}/{len(news_items)}")
else:
score = 8
details.append("Mostly positive/neutral headlines")
return {"score": score, "details": "; ".join(details)}
def generate_fisher_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> PhilFisherSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Phil Fisher AI agent, making investment decisions using his principles:
1. Emphasize long-term growth potential and quality of management.
2. Focus on companies investing in R&D for future products/services.
3. Look for strong profitability and consistent margins.
4. Willing to pay more for exceptional companies but still mindful of valuation.
5. Rely on thorough research (scuttlebutt) and thorough fundamental checks.
When providing your reasoning, be thorough and specific by:
1. Discussing the company's growth prospects in detail with specific metrics and trends
2. Evaluating management quality and their capital allocation decisions
3. Highlighting R&D investments and product pipeline that could drive future growth
4. Assessing consistency of margins and profitability metrics with precise numbers
5. Explaining competitive advantages that could sustain growth over 3-5+ years
6. Using Phil Fisher's methodical, growth-focused, and long-term oriented voice
For example, if bullish: "This company exhibits the sustained growth characteristics we seek, with revenue increasing at 18% annually over five years. Management has demonstrated exceptional foresight by allocating 15% of revenue to R&D, which has produced three promising new product lines. The consistent operating margins of 22-24% indicate pricing power and operational efficiency that should continue to..."
For example, if bearish: "Despite operating in a growing industry, management has failed to translate R&D investments (only 5% of revenue) into meaningful new products. Margins have fluctuated between 10-15%, showing inconsistent operational execution. The company faces increasing competition from three larger competitors with superior distribution networks. Given these concerns about long-term growth sustainability..."
You must output a JSON object with:
- "signal": "bullish" or "bearish" or "neutral"
- "confidence": a float between 0 and 100
- "reasoning": a detailed explanation
""",
),
(
"human",
"""Based on the following analysis, create a Phil Fisher-style investment signal.
Analysis Data for {ticker}:
{analysis_data}
Return the trading signal in this JSON format:
{{
"signal": "bullish/bearish/neutral",
"confidence": float (0-100),
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def create_default_signal():
return PhilFisherSignal(
signal="neutral",
confidence=0.0,
reasoning="Error in analysis, defaulting to neutral"
)
return call_llm(
prompt=prompt,
pydantic_model=PhilFisherSignal,
state=state,
agent_name=agent_id,
default_factory=create_default_signal,
) | --- +++ @@ -22,6 +22,17 @@
def phil_fisher_agent(state: AgentState, agent_id: str = "phil_fisher_agent"):
+ """
+ Analyzes stocks using Phil Fisher's investing principles:
+ - Seek companies with long-term above-average growth potential
+ - Emphasize quality of management and R&D
+ - Look for strong margins, consistent growth, and manageable leverage
+ - Combine fundamental 'scuttlebutt' style checks with basic sentiment and insider data
+ - Willing to pay up for quality, but still mindful of valuation
+ - Generally focuses on long-term compounding
+
+ Returns a bullish/bearish/neutral signal with confidence and reasoning.
+ """
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
@@ -154,6 +165,12 @@
def analyze_fisher_growth_quality(financial_line_items: list) -> dict:
+ """
+ Evaluate growth & quality:
+ - Consistent Revenue Growth
+ - Consistent EPS Growth
+ - R&D as a % of Revenue (if relevant, indicative of future-oriented spending)
+ """
if not financial_line_items or len(financial_line_items) < 2:
return {
"score": 0,
@@ -243,6 +260,9 @@
def analyze_margins_stability(financial_line_items: list) -> dict:
+ """
+ Looks at margin consistency (gross/operating margin) and general stability over time.
+ """
if not financial_line_items or len(financial_line_items) < 2:
return {
"score": 0,
@@ -306,6 +326,12 @@
def analyze_management_efficiency_leverage(financial_line_items: list) -> dict:
+ """
+ Evaluate management efficiency & leverage:
+ - Return on Equity (ROE)
+ - Debt-to-Equity ratio
+ - Possibly check if free cash flow is consistently positive
+ """
if not financial_line_items:
return {
"score": 0,
@@ -376,6 +402,13 @@
def analyze_fisher_valuation(financial_line_items: list, market_cap: float | None) -> dict:
+ """
+ Phil Fisher is willing to pay for quality and growth, but still checks:
+ - P/E
+ - P/FCF
+ - (Optionally) Enterprise Value metrics, but simpler approach is typical
+ We will grant up to 2 points for each of two metrics => max 4 raw => scale to 0–10.
+ """
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data to perform valuation"}
@@ -426,6 +459,12 @@
def analyze_insider_activity(insider_trades: list) -> dict:
+ """
+ Simple insider-trade analysis:
+ - If there's heavy insider buying, we nudge the score up.
+ - If there's mostly selling, we reduce it.
+ - Otherwise, neutral.
+ """
# Default is neutral (5/10).
score = 5
details = []
@@ -462,6 +501,9 @@
def analyze_sentiment(news_items: list) -> dict:
+ """
+ Basic news sentiment: negative keyword check vs. overall volume.
+ """
if not news_items:
return {"score": 5, "details": "No news data; defaulting to neutral sentiment"}
@@ -492,6 +534,9 @@ state: AgentState,
agent_id: str,
) -> PhilFisherSignal:
+ """
+ Generates a JSON signal in the style of Phil Fisher.
+ """
template = ChatPromptTemplate.from_messages(
[
(
@@ -555,4 +600,4 @@ state=state,
agent_name=agent_id,
default_factory=create_default_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/phil_fisher.py |
Add professional docstrings to my codebase | from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import (
get_market_cap,
search_line_items,
get_insider_trades,
get_company_news,
)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from pydantic import BaseModel
import json
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
from src.utils.api_key import get_api_key_from_state
class PeterLynchSignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def peter_lynch_agent(state: AgentState, agent_id: str = "peter_lynch_agent"):
data = state["data"]
end_date = data["end_date"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
analysis_data = {}
lynch_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Gathering financial line items")
# Relevant line items for Peter Lynch's approach
financial_line_items = search_line_items(
ticker,
[
"revenue",
"earnings_per_share",
"net_income",
"operating_income",
"gross_margin",
"operating_margin",
"free_cash_flow",
"capital_expenditure",
"cash_and_equivalents",
"total_debt",
"shareholders_equity",
"outstanding_shares",
],
end_date,
period="annual",
limit=5,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Getting market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching insider trades")
insider_trades = get_insider_trades(ticker, end_date, limit=50, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching company news")
company_news = get_company_news(ticker, end_date, limit=50, api_key=api_key)
# Perform sub-analyses:
progress.update_status(agent_id, ticker, "Analyzing growth")
growth_analysis = analyze_lynch_growth(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing fundamentals")
fundamentals_analysis = analyze_lynch_fundamentals(financial_line_items)
progress.update_status(agent_id, ticker, "Analyzing valuation (focus on PEG)")
valuation_analysis = analyze_lynch_valuation(financial_line_items, market_cap)
progress.update_status(agent_id, ticker, "Analyzing sentiment")
sentiment_analysis = analyze_sentiment(company_news)
progress.update_status(agent_id, ticker, "Analyzing insider activity")
insider_activity = analyze_insider_activity(insider_trades)
# Combine partial scores with weights typical for Peter Lynch:
# 30% Growth, 25% Valuation, 20% Fundamentals,
# 15% Sentiment, 10% Insider Activity = 100%
total_score = (
growth_analysis["score"] * 0.30
+ valuation_analysis["score"] * 0.25
+ fundamentals_analysis["score"] * 0.20
+ sentiment_analysis["score"] * 0.15
+ insider_activity["score"] * 0.10
)
max_possible_score = 10.0
# Map final score to signal
if total_score >= 7.5:
signal = "bullish"
elif total_score <= 4.5:
signal = "bearish"
else:
signal = "neutral"
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_possible_score,
"growth_analysis": growth_analysis,
"valuation_analysis": valuation_analysis,
"fundamentals_analysis": fundamentals_analysis,
"sentiment_analysis": sentiment_analysis,
"insider_activity": insider_activity,
}
progress.update_status(agent_id, ticker, "Generating Peter Lynch analysis")
lynch_output = generate_lynch_output(
ticker=ticker,
analysis_data=analysis_data[ticker],
state=state,
agent_id=agent_id,
)
lynch_analysis[ticker] = {
"signal": lynch_output.signal,
"confidence": lynch_output.confidence,
"reasoning": lynch_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=lynch_output.reasoning)
# Wrap up results
message = HumanMessage(content=json.dumps(lynch_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(lynch_analysis, "Peter Lynch Agent")
# Save signals to state
state["data"]["analyst_signals"][agent_id] = lynch_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
def analyze_lynch_growth(financial_line_items: list) -> dict:
if not financial_line_items or len(financial_line_items) < 2:
return {"score": 0, "details": "Insufficient financial data for growth analysis"}
details = []
raw_score = 0 # We'll sum up points, then scale to 0–10 eventually
# 1) Revenue Growth
revenues = [fi.revenue for fi in financial_line_items if fi.revenue is not None]
if len(revenues) >= 2:
latest_rev = revenues[0]
older_rev = revenues[-1]
if older_rev > 0:
rev_growth = (latest_rev - older_rev) / abs(older_rev)
if rev_growth > 0.25:
raw_score += 3
details.append(f"Strong revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.10:
raw_score += 2
details.append(f"Moderate revenue growth: {rev_growth:.1%}")
elif rev_growth > 0.02:
raw_score += 1
details.append(f"Slight revenue growth: {rev_growth:.1%}")
else:
details.append(f"Flat or negative revenue growth: {rev_growth:.1%}")
else:
details.append("Older revenue is zero/negative; can't compute revenue growth.")
else:
details.append("Not enough revenue data to assess growth.")
# 2) EPS Growth
eps_values = [fi.earnings_per_share for fi in financial_line_items if fi.earnings_per_share is not None]
if len(eps_values) >= 2:
latest_eps = eps_values[0]
older_eps = eps_values[-1]
if abs(older_eps) > 1e-9:
eps_growth = (latest_eps - older_eps) / abs(older_eps)
if eps_growth > 0.25:
raw_score += 3
details.append(f"Strong EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.10:
raw_score += 2
details.append(f"Moderate EPS growth: {eps_growth:.1%}")
elif eps_growth > 0.02:
raw_score += 1
details.append(f"Slight EPS growth: {eps_growth:.1%}")
else:
details.append(f"Minimal or negative EPS growth: {eps_growth:.1%}")
else:
details.append("Older EPS is near zero; skipping EPS growth calculation.")
else:
details.append("Not enough EPS data for growth calculation.")
# raw_score can be up to 6 => scale to 0–10
final_score = min(10, (raw_score / 6) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_lynch_fundamentals(financial_line_items: list) -> dict:
if not financial_line_items:
return {"score": 0, "details": "Insufficient fundamentals data"}
details = []
raw_score = 0 # We'll accumulate up to 6 points, then scale to 0–10
# 1) Debt-to-Equity
debt_values = [fi.total_debt for fi in financial_line_items if fi.total_debt is not None]
eq_values = [fi.shareholders_equity for fi in financial_line_items if fi.shareholders_equity is not None]
if debt_values and eq_values and len(debt_values) == len(eq_values) and len(debt_values) > 0:
recent_debt = debt_values[0]
recent_equity = eq_values[0] if eq_values[0] else 1e-9
de_ratio = recent_debt / recent_equity
if de_ratio < 0.5:
raw_score += 2
details.append(f"Low debt-to-equity: {de_ratio:.2f}")
elif de_ratio < 1.0:
raw_score += 1
details.append(f"Moderate debt-to-equity: {de_ratio:.2f}")
else:
details.append(f"High debt-to-equity: {de_ratio:.2f}")
else:
details.append("No consistent debt/equity data available.")
# 2) Operating Margin
om_values = [fi.operating_margin for fi in financial_line_items if fi.operating_margin is not None]
if om_values:
om_recent = om_values[0]
if om_recent > 0.20:
raw_score += 2
details.append(f"Strong operating margin: {om_recent:.1%}")
elif om_recent > 0.10:
raw_score += 1
details.append(f"Moderate operating margin: {om_recent:.1%}")
else:
details.append(f"Low operating margin: {om_recent:.1%}")
else:
details.append("No operating margin data available.")
# 3) Positive Free Cash Flow
fcf_values = [fi.free_cash_flow for fi in financial_line_items if fi.free_cash_flow is not None]
if fcf_values and fcf_values[0] is not None:
if fcf_values[0] > 0:
raw_score += 2
details.append(f"Positive free cash flow: {fcf_values[0]:,.0f}")
else:
details.append(f"Recent FCF is negative: {fcf_values[0]:,.0f}")
else:
details.append("No free cash flow data available.")
# raw_score up to 6 => scale to 0–10
final_score = min(10, (raw_score / 6) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_lynch_valuation(financial_line_items: list, market_cap: float | None) -> dict:
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data for valuation"}
details = []
raw_score = 0
# Gather data for P/E
net_incomes = [fi.net_income for fi in financial_line_items if fi.net_income is not None]
eps_values = [fi.earnings_per_share for fi in financial_line_items if fi.earnings_per_share is not None]
# Approximate P/E via (market cap / net income) if net income is positive
pe_ratio = None
if net_incomes and net_incomes[0] and net_incomes[0] > 0:
pe_ratio = market_cap / net_incomes[0]
details.append(f"Estimated P/E: {pe_ratio:.2f}")
else:
details.append("No positive net income => can't compute approximate P/E")
# If we have at least 2 EPS data points, let's estimate growth
eps_growth_rate = None
if len(eps_values) >= 2:
latest_eps = eps_values[0]
older_eps = eps_values[-1]
if older_eps > 0:
# Calculate annualized growth rate (CAGR) for PEG ratio
num_years = len(eps_values) - 1
if latest_eps > 0:
# CAGR formula: (ending_value/beginning_value)^(1/years) - 1
eps_growth_rate = (latest_eps / older_eps) ** (1 / num_years) - 1
else:
# If latest EPS is negative, use simple average growth
eps_growth_rate = (latest_eps - older_eps) / (older_eps * num_years)
details.append(f"Annualized EPS growth rate: {eps_growth_rate:.1%}")
else:
details.append("Cannot compute EPS growth rate (older EPS <= 0)")
else:
details.append("Not enough EPS data to compute growth rate")
# Compute PEG if possible
peg_ratio = None
if pe_ratio and eps_growth_rate and eps_growth_rate > 0:
# PEG ratio formula: P/E divided by growth rate (as percentage)
# Since eps_growth_rate is stored as decimal (0.25 for 25%),
# we multiply by 100 to convert to percentage for the PEG calculation
# Example: P/E=20, growth=0.25 (25%) => PEG = 20/25 = 0.8
peg_ratio = pe_ratio / (eps_growth_rate * 100)
details.append(f"PEG ratio: {peg_ratio:.2f}")
# Scoring logic:
# - P/E < 15 => +2, < 25 => +1
# - PEG < 1 => +3, < 2 => +2, < 3 => +1
if pe_ratio is not None:
if pe_ratio < 15:
raw_score += 2
elif pe_ratio < 25:
raw_score += 1
if peg_ratio is not None:
if peg_ratio < 1:
raw_score += 3
elif peg_ratio < 2:
raw_score += 2
elif peg_ratio < 3:
raw_score += 1
final_score = min(10, (raw_score / 5) * 10)
return {"score": final_score, "details": "; ".join(details)}
def analyze_sentiment(news_items: list) -> dict:
if not news_items:
return {"score": 5, "details": "No news data; default to neutral sentiment"}
negative_keywords = ["lawsuit", "fraud", "negative", "downturn", "decline", "investigation", "recall"]
negative_count = 0
for news in news_items:
title_lower = (news.title or "").lower()
if any(word in title_lower for word in negative_keywords):
negative_count += 1
details = []
if negative_count > len(news_items) * 0.3:
# More than 30% negative => somewhat bearish => 3/10
score = 3
details.append(f"High proportion of negative headlines: {negative_count}/{len(news_items)}")
elif negative_count > 0:
# Some negativity => 6/10
score = 6
details.append(f"Some negative headlines: {negative_count}/{len(news_items)}")
else:
# Mostly positive => 8/10
score = 8
details.append("Mostly positive or neutral headlines")
return {"score": score, "details": "; ".join(details)}
def analyze_insider_activity(insider_trades: list) -> dict:
# Default 5 (neutral)
score = 5
details = []
if not insider_trades:
details.append("No insider trades data; defaulting to neutral")
return {"score": score, "details": "; ".join(details)}
buys, sells = 0, 0
for trade in insider_trades:
if trade.transaction_shares is not None:
if trade.transaction_shares > 0:
buys += 1
elif trade.transaction_shares < 0:
sells += 1
total = buys + sells
if total == 0:
details.append("No significant buy/sell transactions found; neutral stance")
return {"score": score, "details": "; ".join(details)}
buy_ratio = buys / total
if buy_ratio > 0.7:
# Heavy buying => +3 => total 8
score = 8
details.append(f"Heavy insider buying: {buys} buys vs. {sells} sells")
elif buy_ratio > 0.4:
# Some buying => +1 => total 6
score = 6
details.append(f"Moderate insider buying: {buys} buys vs. {sells} sells")
else:
# Mostly selling => -1 => total 4
score = 4
details.append(f"Mostly insider selling: {buys} buys vs. {sells} sells")
return {"score": score, "details": "; ".join(details)}
def generate_lynch_output(
ticker: str,
analysis_data: dict[str, any],
state: AgentState,
agent_id: str,
) -> PeterLynchSignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a Peter Lynch AI agent. You make investment decisions based on Peter Lynch's well-known principles:
1. Invest in What You Know: Emphasize understandable businesses, possibly discovered in everyday life.
2. Growth at a Reasonable Price (GARP): Rely on the PEG ratio as a prime metric.
3. Look for 'Ten-Baggers': Companies capable of growing earnings and share price substantially.
4. Steady Growth: Prefer consistent revenue/earnings expansion, less concern about short-term noise.
5. Avoid High Debt: Watch for dangerous leverage.
6. Management & Story: A good 'story' behind the stock, but not overhyped or too complex.
When you provide your reasoning, do it in Peter Lynch's voice:
- Cite the PEG ratio
- Mention 'ten-bagger' potential if applicable
- Refer to personal or anecdotal observations (e.g., "If my kids love the product...")
- Use practical, folksy language
- Provide key positives and negatives
- Conclude with a clear stance (bullish, bearish, or neutral)
Return your final output strictly in JSON with the fields:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": 0 to 100,
"reasoning": "string"
}}
""",
),
(
"human",
"""Based on the following analysis data for {ticker}, produce your Peter Lynch–style investment signal.
Analysis Data:
{analysis_data}
Return only valid JSON with "signal", "confidence", and "reasoning".
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
def create_default_signal():
return PeterLynchSignal(
signal="neutral",
confidence=0.0,
reasoning="Error in analysis; defaulting to neutral"
)
return call_llm(
prompt=prompt,
pydantic_model=PeterLynchSignal,
agent_name=agent_id,
state=state,
default_factory=create_default_signal,
) | --- +++ @@ -16,12 +16,28 @@
class PeterLynchSignal(BaseModel):
+ """
+ Container for the Peter Lynch-style output signal.
+ """
signal: Literal["bullish", "bearish", "neutral"]
confidence: float
reasoning: str
def peter_lynch_agent(state: AgentState, agent_id: str = "peter_lynch_agent"):
+ """
+ Analyzes stocks using Peter Lynch's investing principles:
+ - Invest in what you know (clear, understandable businesses).
+ - Growth at a Reasonable Price (GARP), emphasizing the PEG ratio.
+ - Look for consistent revenue & EPS increases and manageable debt.
+ - Be alert for potential "ten-baggers" (high-growth opportunities).
+ - Avoid overly complex or highly leveraged businesses.
+ - Use news sentiment and insider trades for secondary inputs.
+ - If fundamentals strongly align with GARP, be more aggressive.
+
+ The result is a bullish/bearish/neutral signal, along with a
+ confidence (0–100) and a textual reasoning explanation.
+ """
data = state["data"]
end_date = data["end_date"]
@@ -143,6 +159,13 @@
def analyze_lynch_growth(financial_line_items: list) -> dict:
+ """
+ Evaluate growth based on revenue and EPS trends:
+ - Consistent revenue growth
+ - Consistent EPS growth
+ Peter Lynch liked companies with steady, understandable growth,
+ often searching for potential 'ten-baggers' with a long runway.
+ """
if not financial_line_items or len(financial_line_items) < 2:
return {"score": 0, "details": "Insufficient financial data for growth analysis"}
@@ -201,6 +224,13 @@
def analyze_lynch_fundamentals(financial_line_items: list) -> dict:
+ """
+ Evaluate basic fundamentals:
+ - Debt/Equity
+ - Operating margin (or gross margin)
+ - Positive Free Cash Flow
+ Lynch avoided heavily indebted or complicated businesses.
+ """
if not financial_line_items:
return {"score": 0, "details": "Insufficient fundamentals data"}
@@ -257,6 +287,12 @@
def analyze_lynch_valuation(financial_line_items: list, market_cap: float | None) -> dict:
+ """
+ Peter Lynch's approach to 'Growth at a Reasonable Price' (GARP):
+ - Emphasize the PEG ratio: (P/E) / Growth Rate
+ - Also consider a basic P/E if PEG is unavailable
+ A PEG < 1 is very attractive; 1-2 is fair; >2 is expensive.
+ """
if not financial_line_items or market_cap is None:
return {"score": 0, "details": "Insufficient data for valuation"}
@@ -327,6 +363,9 @@
def analyze_sentiment(news_items: list) -> dict:
+ """
+ Basic news sentiment check. Negative headlines weigh on the final score.
+ """
if not news_items:
return {"score": 5, "details": "No news data; default to neutral sentiment"}
@@ -355,6 +394,12 @@
def analyze_insider_activity(insider_trades: list) -> dict:
+ """
+ Simple insider-trade analysis:
+ - If there's heavy insider buying, it's a positive sign.
+ - If there's mostly selling, it's a negative sign.
+ - Otherwise, neutral.
+ """
# Default 5 (neutral)
score = 5
details = []
@@ -399,6 +444,9 @@ state: AgentState,
agent_id: str,
) -> PeterLynchSignal:
+ """
+ Generates a final JSON signal in Peter Lynch's voice & style.
+ """
template = ChatPromptTemplate.from_messages(
[
(
@@ -456,4 +504,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/peter_lynch.py |
Improve documentation using docstrings |
from typing import Dict, Optional, Any, TypedDict
from ..services.data_service import DataService
from ..utils.validators import validate_config_section
from ..utils.errors import MCPError
class ErrorInfo(TypedDict, total=False):
code: str
message: str
suggestion: str
class ConfigResult(TypedDict):
success: bool
config: Optional[Dict[str, Any]]
section: Optional[str]
error: Optional[ErrorInfo]
class ConfigManagementTools:
def __init__(self, project_root: str = None):
self.data_service = DataService(project_root)
def get_current_config(self, section: Optional[str] = None) -> ConfigResult:
try:
# 参数验证
section = validate_config_section(section)
# 获取配置
config = self.data_service.get_current_config(section=section)
return ConfigResult(
success=True,
config=config,
section=section,
error=None
)
except MCPError as e:
return ConfigResult(
success=False,
config=None,
section=None,
error=e.to_dict()
)
except Exception as e:
return ConfigResult(
success=False,
config=None,
section=None,
error={"code": "INTERNAL_ERROR", "message": str(e), "suggestion": "请查看服务日志获取详细信息"}
) | --- +++ @@ -1,3 +1,8 @@+"""
+配置管理工具
+
+实现配置查询和管理功能。
+"""
from typing import Dict, Optional, Any, TypedDict
@@ -7,12 +12,14 @@
class ErrorInfo(TypedDict, total=False):
+ """错误信息结构"""
code: str
message: str
suggestion: str
class ConfigResult(TypedDict):
+ """配置查询结果 - success 字段必需，其他字段可选"""
success: bool
config: Optional[Dict[str, Any]]
section: Optional[str]
@@ -20,11 +27,32 @@
class ConfigManagementTools:
+ """配置管理工具类"""
def __init__(self, project_root: str = None):
+ """
+ 初始化配置管理工具
+
+ Args:
+ project_root: 项目根目录
+ """
self.data_service = DataService(project_root)
def get_current_config(self, section: Optional[str] = None) -> ConfigResult:
+ """
+ 获取当前系统配置
+
+ Args:
+ section: 配置节 - all/crawler/push/keywords/weights，默认all
+
+ Returns:
+ 配置字典
+
+ Example:
+ >>> tools = ConfigManagementTools()
+ >>> result = tools.get_current_config(section="crawler")
+ >>> print(result['crawler']['platforms'])
+ """
try:
# 参数验证
section = validate_config_section(section)
@@ -52,4 +80,4 @@ config=None,
section=None,
error={"code": "INTERNAL_ERROR", "message": str(e), "suggestion": "请查看服务日志获取详细信息"}
- )+ )
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/tools/config_mgmt.py |
Include argument descriptions in docstrings | from __future__ import annotations
from datetime import datetime, timedelta
import json
from typing_extensions import Literal
from src.graph.state import AgentState, show_agent_reasoning
from langchain_core.messages import HumanMessage
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel
from src.tools.api import (
get_company_news,
get_financial_metrics,
get_insider_trades,
get_market_cap,
search_line_items,
)
from src.utils.llm import call_llm
from src.utils.progress import progress
from src.utils.api_key import get_api_key_from_state
class MichaelBurrySignal(BaseModel):
signal: Literal["bullish", "bearish", "neutral"]
confidence: float # 0–100
reasoning: str
def michael_burry_agent(state: AgentState, agent_id: str = "michael_burry_agent"):
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
data = state["data"]
end_date: str = data["end_date"] # YYYY‑MM‑DD
tickers: list[str] = data["tickers"]
# We look one year back for insider trades / news flow
start_date = (datetime.fromisoformat(end_date) - timedelta(days=365)).date().isoformat()
analysis_data: dict[str, dict] = {}
burry_analysis: dict[str, dict] = {}
for ticker in tickers:
# ------------------------------------------------------------------
# Fetch raw data
# ------------------------------------------------------------------
progress.update_status(agent_id, ticker, "Fetching financial metrics")
metrics = get_financial_metrics(ticker, end_date, period="ttm", limit=5, api_key=api_key)
progress.update_status(agent_id, ticker, "Fetching line items")
line_items = search_line_items(
ticker,
[
"free_cash_flow",
"net_income",
"total_debt",
"cash_and_equivalents",
"total_assets",
"total_liabilities",
"outstanding_shares",
"issuance_or_purchase_of_equity_shares",
],
end_date,
api_key=api_key,
)
progress.update_status(agent_id, ticker, "Fetching insider trades")
insider_trades = get_insider_trades(ticker, end_date=end_date, start_date=start_date)
progress.update_status(agent_id, ticker, "Fetching company news")
news = get_company_news(ticker, end_date=end_date, start_date=start_date, limit=250)
progress.update_status(agent_id, ticker, "Fetching market cap")
market_cap = get_market_cap(ticker, end_date, api_key=api_key)
# ------------------------------------------------------------------
# Run sub‑analyses
# ------------------------------------------------------------------
progress.update_status(agent_id, ticker, "Analyzing value")
value_analysis = _analyze_value(metrics, line_items, market_cap)
progress.update_status(agent_id, ticker, "Analyzing balance sheet")
balance_sheet_analysis = _analyze_balance_sheet(metrics, line_items)
progress.update_status(agent_id, ticker, "Analyzing insider activity")
insider_analysis = _analyze_insider_activity(insider_trades)
progress.update_status(agent_id, ticker, "Analyzing contrarian sentiment")
contrarian_analysis = _analyze_contrarian_sentiment(news)
# ------------------------------------------------------------------
# Aggregate score & derive preliminary signal
# ------------------------------------------------------------------
total_score = (
value_analysis["score"]
+ balance_sheet_analysis["score"]
+ insider_analysis["score"]
+ contrarian_analysis["score"]
)
max_score = (
value_analysis["max_score"]
+ balance_sheet_analysis["max_score"]
+ insider_analysis["max_score"]
+ contrarian_analysis["max_score"]
)
if total_score >= 0.7 * max_score:
signal = "bullish"
elif total_score <= 0.3 * max_score:
signal = "bearish"
else:
signal = "neutral"
# ------------------------------------------------------------------
# Collect data for LLM reasoning & output
# ------------------------------------------------------------------
analysis_data[ticker] = {
"signal": signal,
"score": total_score,
"max_score": max_score,
"value_analysis": value_analysis,
"balance_sheet_analysis": balance_sheet_analysis,
"insider_analysis": insider_analysis,
"contrarian_analysis": contrarian_analysis,
"market_cap": market_cap,
}
progress.update_status(agent_id, ticker, "Generating LLM output")
burry_output = _generate_burry_output(
ticker=ticker,
analysis_data=analysis_data,
state=state,
agent_id=agent_id,
)
burry_analysis[ticker] = {
"signal": burry_output.signal,
"confidence": burry_output.confidence,
"reasoning": burry_output.reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=burry_output.reasoning)
# ----------------------------------------------------------------------
# Return to the graph
# ----------------------------------------------------------------------
message = HumanMessage(content=json.dumps(burry_analysis), name=agent_id)
if state["metadata"].get("show_reasoning"):
show_agent_reasoning(burry_analysis, "Michael Burry Agent")
state["data"]["analyst_signals"][agent_id] = burry_analysis
progress.update_status(agent_id, None, "Done")
return {"messages": [message], "data": state["data"]}
###############################################################################
# Sub‑analysis helpers
###############################################################################
def _latest_line_item(line_items: list):
return line_items[0] if line_items else None
# ----- Value ----------------------------------------------------------------
def _analyze_value(metrics, line_items, market_cap):
max_score = 6 # 4 pts for FCF‑yield, 2 pts for EV/EBIT
score = 0
details: list[str] = []
# Free‑cash‑flow yield
latest_item = _latest_line_item(line_items)
fcf = getattr(latest_item, "free_cash_flow", None) if latest_item else None
if fcf is not None and market_cap:
fcf_yield = fcf / market_cap
if fcf_yield >= 0.15:
score += 4
details.append(f"Extraordinary FCF yield {fcf_yield:.1%}")
elif fcf_yield >= 0.12:
score += 3
details.append(f"Very high FCF yield {fcf_yield:.1%}")
elif fcf_yield >= 0.08:
score += 2
details.append(f"Respectable FCF yield {fcf_yield:.1%}")
else:
details.append(f"Low FCF yield {fcf_yield:.1%}")
else:
details.append("FCF data unavailable")
# EV/EBIT (from financial metrics)
if metrics:
ev_ebit = getattr(metrics[0], "ev_to_ebit", None)
if ev_ebit is not None:
if ev_ebit < 6:
score += 2
details.append(f"EV/EBIT {ev_ebit:.1f} (<6)")
elif ev_ebit < 10:
score += 1
details.append(f"EV/EBIT {ev_ebit:.1f} (<10)")
else:
details.append(f"High EV/EBIT {ev_ebit:.1f}")
else:
details.append("EV/EBIT data unavailable")
else:
details.append("Financial metrics unavailable")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
# ----- Balance sheet --------------------------------------------------------
def _analyze_balance_sheet(metrics, line_items):
max_score = 3
score = 0
details: list[str] = []
latest_metrics = metrics[0] if metrics else None
latest_item = _latest_line_item(line_items)
debt_to_equity = getattr(latest_metrics, "debt_to_equity", None) if latest_metrics else None
if debt_to_equity is not None:
if debt_to_equity < 0.5:
score += 2
details.append(f"Low D/E {debt_to_equity:.2f}")
elif debt_to_equity < 1:
score += 1
details.append(f"Moderate D/E {debt_to_equity:.2f}")
else:
details.append(f"High leverage D/E {debt_to_equity:.2f}")
else:
details.append("Debt‑to‑equity data unavailable")
# Quick liquidity sanity check (cash vs total debt)
if latest_item is not None:
cash = getattr(latest_item, "cash_and_equivalents", None)
total_debt = getattr(latest_item, "total_debt", None)
if cash is not None and total_debt is not None:
if cash > total_debt:
score += 1
details.append("Net cash position")
else:
details.append("Net debt position")
else:
details.append("Cash/debt data unavailable")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
# ----- Insider activity -----------------------------------------------------
def _analyze_insider_activity(insider_trades):
max_score = 2
score = 0
details: list[str] = []
if not insider_trades:
details.append("No insider trade data")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
shares_bought = sum(t.transaction_shares or 0 for t in insider_trades if (t.transaction_shares or 0) > 0)
shares_sold = abs(sum(t.transaction_shares or 0 for t in insider_trades if (t.transaction_shares or 0) < 0))
net = shares_bought - shares_sold
if net > 0:
score += 2 if net / max(shares_sold, 1) > 1 else 1
details.append(f"Net insider buying of {net:,} shares")
else:
details.append("Net insider selling")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
# ----- Contrarian sentiment -------------------------------------------------
def _analyze_contrarian_sentiment(news):
max_score = 1
score = 0
details: list[str] = []
if not news:
details.append("No recent news")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
# Count negative sentiment articles
sentiment_negative_count = sum(
1 for n in news if n.sentiment and n.sentiment.lower() in ["negative", "bearish"]
)
if sentiment_negative_count >= 5:
score += 1 # The more hated, the better (assuming fundamentals hold up)
details.append(f"{sentiment_negative_count} negative headlines (contrarian opportunity)")
else:
details.append("Limited negative press")
return {"score": score, "max_score": max_score, "details": "; ".join(details)}
###############################################################################
# LLM generation
###############################################################################
def _generate_burry_output(
ticker: str,
analysis_data: dict,
state: AgentState,
agent_id: str,
) -> MichaelBurrySignal:
template = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are an AI agent emulating Dr. Michael J. Burry. Your mandate:
- Hunt for deep value in US equities using hard numbers (free cash flow, EV/EBIT, balance sheet)
- Be contrarian: hatred in the press can be your friend if fundamentals are solid
- Focus on downside first – avoid leveraged balance sheets
- Look for hard catalysts such as insider buying, buybacks, or asset sales
- Communicate in Burry's terse, data‑driven style
When providing your reasoning, be thorough and specific by:
1. Start with the key metric(s) that drove your decision
2. Cite concrete numbers (e.g. "FCF yield 14.7%", "EV/EBIT 5.3")
3. Highlight risk factors and why they are acceptable (or not)
4. Mention relevant insider activity or contrarian opportunities
5. Use Burry's direct, number-focused communication style with minimal words
For example, if bullish: "FCF yield 12.8%. EV/EBIT 6.2. Debt-to-equity 0.4. Net insider buying 25k shares. Market missing value due to overreaction to recent litigation. Strong buy."
For example, if bearish: "FCF yield only 2.1%. Debt-to-equity concerning at 2.3. Management diluting shareholders. Pass."
""",
),
(
"human",
"""Based on the following data, create the investment signal as Michael Burry would:
Analysis Data for {ticker}:
{analysis_data}
Return the trading signal in the following JSON format exactly:
{{
"signal": "bullish" | "bearish" | "neutral",
"confidence": float between 0 and 100,
"reasoning": "string"
}}
""",
),
]
)
prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
# Default fallback signal in case parsing fails
def create_default_michael_burry_signal():
return MichaelBurrySignal(signal="neutral", confidence=0.0, reasoning="Parsing error – defaulting to neutral")
return call_llm(
prompt=prompt,
pydantic_model=MichaelBurrySignal,
agent_name=agent_id,
state=state,
default_factory=create_default_michael_burry_signal,
) | --- +++ @@ -22,6 +22,7 @@
class MichaelBurrySignal(BaseModel):
+ """Schema returned by the LLM."""
signal: Literal["bullish", "bearish", "neutral"]
confidence: float # 0–100
@@ -29,6 +30,7 @@
def michael_burry_agent(state: AgentState, agent_id: str = "michael_burry_agent"):
+ """Analyse stocks using Michael Burry's deep‑value, contrarian framework."""
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
data = state["data"]
end_date: str = data["end_date"] # YYYY‑MM‑DD
@@ -162,12 +164,14 @@
def _latest_line_item(line_items: list):
+ """Return the most recent line‑item object or *None*."""
return line_items[0] if line_items else None
# ----- Value ----------------------------------------------------------------
def _analyze_value(metrics, line_items, market_cap):
+ """Free cash‑flow yield, EV/EBIT, other classic deep‑value metrics."""
max_score = 6 # 4 pts for FCF‑yield, 2 pts for EV/EBIT
score = 0
@@ -215,6 +219,7 @@ # ----- Balance sheet --------------------------------------------------------
def _analyze_balance_sheet(metrics, line_items):
+ """Leverage and liquidity checks."""
max_score = 3
score = 0
@@ -255,6 +260,7 @@ # ----- Insider activity -----------------------------------------------------
def _analyze_insider_activity(insider_trades):
+ """Net insider buying over the last 12 months acts as a hard catalyst."""
max_score = 2
score = 0
@@ -279,6 +285,7 @@ # ----- Contrarian sentiment -------------------------------------------------
def _analyze_contrarian_sentiment(news):
+ """Very rough gauge: a wall of recent negative headlines can be a *positive* for a contrarian."""
max_score = 1
score = 0
@@ -312,6 +319,7 @@ state: AgentState,
agent_id: str,
) -> MichaelBurrySignal:
+ """Call the LLM to craft the final trading signal in Burry's voice."""
template = ChatPromptTemplate.from_messages(
[
@@ -365,4 +373,4 @@ agent_name=agent_id,
state=state,
default_factory=create_default_michael_burry_signal,
- )+ )
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/michael_burry.py |
Fully document this Python code with docstrings |
import time
from typing import Dict, List
import requests
from ..utils.errors import MCPError, InvalidParameterError
# Jina Reader 配置
JINA_READER_BASE = "https://r.jina.ai"
DEFAULT_TIMEOUT = 30 # 秒
MAX_BATCH_SIZE = 5 # 单次批量最大篇数
BATCH_INTERVAL = 5.0 # 批量请求间隔（秒）
class ArticleReaderTools:
def __init__(self, project_root: str = None, jina_api_key: str = None):
self.project_root = project_root
self.jina_api_key = jina_api_key
self._last_request_time = 0.0
def _build_headers(self) -> Dict[str, str]:
headers = {
"Accept": "text/markdown",
"X-Return-Format": "markdown",
"X-No-Cache": "true",
}
if self.jina_api_key:
headers["Authorization"] = f"Bearer {self.jina_api_key}"
return headers
def _throttle(self):
now = time.time()
elapsed = now - self._last_request_time
if elapsed < BATCH_INTERVAL:
time.sleep(BATCH_INTERVAL - elapsed)
self._last_request_time = time.time()
def read_article(
self,
url: str,
timeout: int = DEFAULT_TIMEOUT
) -> Dict:
try:
if not url or not url.startswith(("http://", "https://")):
raise InvalidParameterError(
f"无效的 URL: {url}",
suggestion="URL 必须以 http:// 或 https:// 开头"
)
self._throttle()
response = requests.get(
f"{JINA_READER_BASE}/{url}",
headers=self._build_headers(),
timeout=timeout
)
if response.status_code == 200:
return {
"success": True,
"data": {
"url": url,
"content": response.text,
"format": "markdown",
"content_length": len(response.text)
}
}
elif response.status_code == 429:
return {
"success": False,
"error": {
"code": "RATE_LIMITED",
"message": "Jina Reader 速率限制，请稍后重试",
"suggestion": "免费限制: 100 RPM / 2 并发，可配置 API Key 提升限额"
}
}
else:
return {
"success": False,
"error": {
"code": "FETCH_FAILED",
"message": f"HTTP {response.status_code}: {response.reason}",
"url": url
}
}
except requests.Timeout:
return {
"success": False,
"error": {
"code": "TIMEOUT",
"message": f"请求超时（{timeout}秒）",
"url": url,
"suggestion": "可尝试增加 timeout 参数"
}
}
except MCPError as e:
return {"success": False, "error": e.to_dict()}
except Exception as e:
return {
"success": False,
"error": {
"code": "REQUEST_ERROR",
"message": str(e),
"url": url
}
}
def read_articles_batch(
self,
urls: List[str],
timeout: int = DEFAULT_TIMEOUT
) -> Dict:
try:
if not urls:
raise InvalidParameterError(
"URL 列表不能为空",
suggestion="请提供至少一个 URL"
)
# 限制最多 5 篇
actual_urls = urls[:MAX_BATCH_SIZE]
skipped = len(urls) - len(actual_urls)
results = []
succeeded = 0
failed = 0
for i, url in enumerate(actual_urls):
result = self.read_article(url=url, timeout=timeout)
results.append({
"index": i + 1,
"url": url,
"success": result["success"],
"data": result.get("data"),
"error": result.get("error")
})
if result["success"]:
succeeded += 1
else:
failed += 1
return {
"success": True,
"summary": {
"description": "批量文章读取结果",
"requested": len(urls),
"processed": len(actual_urls),
"succeeded": succeeded,
"failed": failed,
"skipped": skipped,
"interval_seconds": BATCH_INTERVAL,
},
"articles": results,
"note": f"已跳过 {skipped} 篇（单次上限 {MAX_BATCH_SIZE} 篇）" if skipped > 0 else None
}
except MCPError as e:
return {"success": False, "error": e.to_dict()}
except Exception as e:
return {
"success": False,
"error": {
"code": "BATCH_ERROR",
"message": str(e)
}
} | --- +++ @@ -1,3 +1,10 @@+"""
+文章内容读取工具
+
+通过 Jina AI Reader API 将 URL 转换为 LLM 友好的 Markdown 格式。
+支持单篇和批量读取，内置速率限制和并发控制。
+
+"""
import time
from typing import Dict, List
@@ -15,13 +22,22 @@
class ArticleReaderTools:
+ """文章内容读取工具类"""
def __init__(self, project_root: str = None, jina_api_key: str = None):
+ """
+ 初始化文章读取工具
+
+ Args:
+ project_root: 项目根目录
+ jina_api_key: Jina API Key（可选，有 Key 可提升速率限制）
+ """
self.project_root = project_root
self.jina_api_key = jina_api_key
self._last_request_time = 0.0
def _build_headers(self) -> Dict[str, str]:
+ """构建请求头"""
headers = {
"Accept": "text/markdown",
"X-Return-Format": "markdown",
@@ -32,6 +48,7 @@ return headers
def _throttle(self):
+ """速率控制：确保请求间隔 5 秒"""
now = time.time()
elapsed = now - self._last_request_time
if elapsed < BATCH_INTERVAL:
@@ -43,6 +60,16 @@ url: str,
timeout: int = DEFAULT_TIMEOUT
) -> Dict:
+ """
+ 读取单篇文章内容（Markdown 格式）
+
+ Args:
+ url: 文章链接
+ timeout: 请求超时时间（秒），默认 30
+
+ Returns:
+ 文章内容字典
+ """
try:
if not url or not url.startswith(("http://", "https://")):
raise InvalidParameterError(
@@ -114,6 +141,16 @@ urls: List[str],
timeout: int = DEFAULT_TIMEOUT
) -> Dict:
+ """
+ 批量读取多篇文章内容（最多 5 篇，间隔 5 秒）
+
+ Args:
+ urls: 文章链接列表
+ timeout: 每篇的请求超时时间（秒）
+
+ Returns:
+ 批量读取结果
+ """
try:
if not urls:
raise InvalidParameterError(
@@ -169,4 +206,4 @@ "code": "BATCH_ERROR",
"message": str(e)
}
- }+ }
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/tools/article_reader.py |
Write docstrings for data processing functions |
import hashlib
import json
import time
from typing import Any, Optional
from threading import Lock
def make_cache_key(namespace: str, **params) -> str:
if not params:
return namespace
# 对参数进行规范化处理
normalized_params = {}
for k, v in params.items():
if v is None:
continue # 跳过 None 值
elif isinstance(v, (list, tuple)):
# 列表排序后转为字符串
normalized_params[k] = json.dumps(sorted(v) if all(isinstance(i, str) for i in v) else list(v), ensure_ascii=False)
elif isinstance(v, dict):
# 字典按键排序后转为字符串
normalized_params[k] = json.dumps(v, sort_keys=True, ensure_ascii=False)
else:
normalized_params[k] = str(v)
# 排序参数并生成哈希
sorted_params = sorted(normalized_params.items())
param_str = "&".join(f"{k}={v}" for k, v in sorted_params)
# 使用 MD5 生成短哈希（取前8位）
hash_value = hashlib.md5(param_str.encode('utf-8')).hexdigest()[:8]
return f"{namespace}:{hash_value}"
class CacheService:
def __init__(self):
self._cache = {}
self._timestamps = {}
self._lock = Lock()
def get(self, key: str, ttl: int = 900) -> Optional[Any]:
with self._lock:
if key in self._cache:
# 检查是否过期
if time.time() - self._timestamps[key] < ttl:
return self._cache[key]
else:
# 已过期，删除缓存
del self._cache[key]
del self._timestamps[key]
return None
def set(self, key: str, value: Any) -> None:
with self._lock:
self._cache[key] = value
self._timestamps[key] = time.time()
def delete(self, key: str) -> bool:
with self._lock:
if key in self._cache:
del self._cache[key]
del self._timestamps[key]
return True
return False
def clear(self) -> None:
with self._lock:
self._cache.clear()
self._timestamps.clear()
def cleanup_expired(self, ttl: int = 900) -> int:
with self._lock:
current_time = time.time()
expired_keys = [
key for key, timestamp in self._timestamps.items()
if current_time - timestamp >= ttl
]
for key in expired_keys:
del self._cache[key]
del self._timestamps[key]
return len(expired_keys)
def get_stats(self) -> dict:
with self._lock:
return {
"total_entries": len(self._cache),
"oldest_entry_age": (
time.time() - min(self._timestamps.values())
if self._timestamps else 0
),
"newest_entry_age": (
time.time() - max(self._timestamps.values())
if self._timestamps else 0
)
}
# 全局缓存实例
_global_cache = None
def get_cache() -> CacheService:
global _global_cache
if _global_cache is None:
_global_cache = CacheService()
return _global_cache | --- +++ @@ -1,3 +1,8 @@+"""
+缓存服务
+
+实现TTL缓存机制，提升数据访问性能。
+"""
import hashlib
import json
@@ -7,6 +12,24 @@
def make_cache_key(namespace: str, **params) -> str:
+ """
+ 生成结构化缓存 key
+
+ 通过对参数排序和哈希，确保相同参数组合总是生成相同的 key。
+
+ Args:
+ namespace: 缓存命名空间，如 "latest_news", "trending_topics"
+ **params: 缓存参数
+
+ Returns:
+ 格式化的缓存 key，如 "latest_news:a1b2c3d4"
+
+ Examples:
+ >>> make_cache_key("latest_news", platforms=["zhihu"], limit=50)
+ 'latest_news:8f14e45f'
+ >>> make_cache_key("search", query="AI", mode="keyword")
+ 'search:3c6e0b8a'
+ """
if not params:
return namespace
@@ -35,13 +58,25 @@
class CacheService:
+ """缓存服务类"""
def __init__(self):
+ """初始化缓存服务"""
self._cache = {}
self._timestamps = {}
self._lock = Lock()
def get(self, key: str, ttl: int = 900) -> Optional[Any]:
+ """
+ 获取缓存数据
+
+ Args:
+ key: 缓存键
+ ttl: 存活时间（秒），默认15分钟
+
+ Returns:
+ 缓存的值，如果不存在或已过期则返回None
+ """
with self._lock:
if key in self._cache:
# 检查是否过期
@@ -54,11 +89,27 @@ return None
def set(self, key: str, value: Any) -> None:
+ """
+ 设置缓存数据
+
+ Args:
+ key: 缓存键
+ value: 缓存值
+ """
with self._lock:
self._cache[key] = value
self._timestamps[key] = time.time()
def delete(self, key: str) -> bool:
+ """
+ 删除缓存
+
+ Args:
+ key: 缓存键
+
+ Returns:
+ 是否成功删除
+ """
with self._lock:
if key in self._cache:
del self._cache[key]
@@ -67,11 +118,21 @@ return False
def clear(self) -> None:
+ """清空所有缓存"""
with self._lock:
self._cache.clear()
self._timestamps.clear()
def cleanup_expired(self, ttl: int = 900) -> int:
+ """
+ 清理过期缓存
+
+ Args:
+ ttl: 存活时间（秒）
+
+ Returns:
+ 清理的条目数量
+ """
with self._lock:
current_time = time.time()
expired_keys = [
@@ -86,6 +147,12 @@ return len(expired_keys)
def get_stats(self) -> dict:
+ """
+ 获取缓存统计信息
+
+ Returns:
+ 统计信息字典
+ """
with self._lock:
return {
"total_entries": len(self._cache),
@@ -105,7 +172,13 @@
def get_cache() -> CacheService:
+ """
+ 获取全局缓存实例
+
+ Returns:
+ 全局缓存服务实例
+ """
global _global_cache
if _global_cache is None:
_global_cache = CacheService()
- return _global_cache+ return _global_cache
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/services/cache_service.py |
Add standardized docstrings across the file | from datetime import datetime, timezone
from rich.console import Console
from rich.live import Live
from rich.table import Table
from rich.style import Style
from rich.text import Text
from typing import Dict, Optional, Callable, List
console = Console()
class AgentProgress:
def __init__(self):
self.agent_status: Dict[str, Dict[str, str]] = {}
self.table = Table(show_header=False, box=None, padding=(0, 1))
self.live = Live(self.table, console=console, refresh_per_second=4)
self.started = False
self.update_handlers: List[Callable[[str, Optional[str], str], None]] = []
def register_handler(self, handler: Callable[[str, Optional[str], str], None]):
self.update_handlers.append(handler)
return handler # Return handler to support use as decorator
def unregister_handler(self, handler: Callable[[str, Optional[str], str], None]):
if handler in self.update_handlers:
self.update_handlers.remove(handler)
def start(self):
if not self.started:
self.live.start()
self.started = True
def stop(self):
if self.started:
self.live.stop()
self.started = False
def update_status(self, agent_name: str, ticker: Optional[str] = None, status: str = "", analysis: Optional[str] = None):
if agent_name not in self.agent_status:
self.agent_status[agent_name] = {"status": "", "ticker": None}
if ticker:
self.agent_status[agent_name]["ticker"] = ticker
if status:
self.agent_status[agent_name]["status"] = status
if analysis:
self.agent_status[agent_name]["analysis"] = analysis
# Set the timestamp as UTC datetime
timestamp = datetime.now(timezone.utc).isoformat()
self.agent_status[agent_name]["timestamp"] = timestamp
# Notify all registered handlers
for handler in self.update_handlers:
handler(agent_name, ticker, status, analysis, timestamp)
self._refresh_display()
def get_all_status(self):
return {agent_name: {"ticker": info["ticker"], "status": info["status"], "display_name": self._get_display_name(agent_name)} for agent_name, info in self.agent_status.items()}
def _get_display_name(self, agent_name: str) -> str:
return agent_name.replace("_agent", "").replace("_", " ").title()
def _refresh_display(self):
self.table.columns.clear()
self.table.add_column(width=100)
# Sort agents with Risk Management and Portfolio Management at the bottom
def sort_key(item):
agent_name = item[0]
if "risk_management" in agent_name:
return (2, agent_name)
elif "portfolio_management" in agent_name:
return (3, agent_name)
else:
return (1, agent_name)
for agent_name, info in sorted(self.agent_status.items(), key=sort_key):
status = info["status"]
ticker = info["ticker"]
# Create the status text with appropriate styling
if status.lower() == "done":
style = Style(color="green", bold=True)
symbol = "✓"
elif status.lower() == "error":
style = Style(color="red", bold=True)
symbol = "✗"
else:
style = Style(color="yellow")
symbol = "⋯"
agent_display = self._get_display_name(agent_name)
status_text = Text()
status_text.append(f"{symbol} ", style=style)
status_text.append(f"{agent_display:<20}", style=Style(bold=True))
if ticker:
status_text.append(f"[{ticker}] ", style=Style(color="cyan"))
status_text.append(status, style=style)
self.table.add_row(status_text)
# Create a global instance
progress = AgentProgress() | --- +++ @@ -10,6 +10,7 @@
class AgentProgress:
+ """Manages progress tracking for multiple agents."""
def __init__(self):
self.agent_status: Dict[str, Dict[str, str]] = {}
@@ -19,24 +20,29 @@ self.update_handlers: List[Callable[[str, Optional[str], str], None]] = []
def register_handler(self, handler: Callable[[str, Optional[str], str], None]):
+ """Register a handler to be called when agent status updates."""
self.update_handlers.append(handler)
return handler # Return handler to support use as decorator
def unregister_handler(self, handler: Callable[[str, Optional[str], str], None]):
+ """Unregister a previously registered handler."""
if handler in self.update_handlers:
self.update_handlers.remove(handler)
def start(self):
+ """Start the progress display."""
if not self.started:
self.live.start()
self.started = True
def stop(self):
+ """Stop the progress display."""
if self.started:
self.live.stop()
self.started = False
def update_status(self, agent_name: str, ticker: Optional[str] = None, status: str = "", analysis: Optional[str] = None):
+ """Update the status of an agent."""
if agent_name not in self.agent_status:
self.agent_status[agent_name] = {"status": "", "ticker": None}
@@ -58,12 +64,15 @@ self._refresh_display()
def get_all_status(self):
+ """Get the current status of all agents as a dictionary."""
return {agent_name: {"ticker": info["ticker"], "status": info["status"], "display_name": self._get_display_name(agent_name)} for agent_name, info in self.agent_status.items()}
def _get_display_name(self, agent_name: str) -> str:
+ """Convert agent_name to a display-friendly format."""
return agent_name.replace("_agent", "").replace("_", " ").title()
def _refresh_display(self):
+ """Refresh the progress display."""
self.table.columns.clear()
self.table.add_column(width=100)
@@ -104,4 +113,4 @@
# Create a global instance
-progress = AgentProgress()+progress = AgentProgress()
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/utils/progress.py |
Generate missing documentation strings | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import sys
import subprocess
import time
import signal
from pathlib import Path
from datetime import datetime
# Web 服务器配置
WEBSERVER_PORT = int(os.environ.get("WEBSERVER_PORT", "8080"))
WEBSERVER_DIR = "/app/output"
WEBSERVER_PID_FILE = "/tmp/webserver.pid"
WEBSERVER_MANUAL_STOP_FILE = "/tmp/webserver.manual_stop"
def _env_bool(name: str, default: bool) -> bool:
value = os.environ.get(name)
if value is None:
return default
return value.strip().lower() in {"1", "true", "yes", "on"}
WEBSERVER_AUTOFIX_LOG_HEALTHY = _env_bool("WEBSERVER_AUTOFIX_LOG_HEALTHY", False)
def get_timestamp():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def run_command(cmd, shell=True, capture_output=True):
try:
result = subprocess.run(
cmd, shell=shell, capture_output=capture_output, text=True
)
return result.returncode == 0, result.stdout, result.stderr
except Exception as e:
return False, "", str(e)
def manual_run():
print("🔄 手动执行爬虫...")
try:
result = subprocess.run(
["python", "-m", "trendradar"], cwd="/app", capture_output=False, text=True
)
if result.returncode == 0:
print("✅ 执行完成")
else:
print(f"❌ 执行失败，退出码: {result.returncode}")
except Exception as e:
print(f"❌ 执行出错: {e}")
def parse_cron_schedule(cron_expr):
if not cron_expr or cron_expr == "未设置":
return "未设置"
try:
parts = cron_expr.strip().split()
if len(parts) != 5:
return f"原始表达式: {cron_expr}"
minute, hour, day, month, weekday = parts
# 分析分钟
if minute == "*":
minute_desc = "每分钟"
elif minute.startswith("*/"):
interval = minute[2:]
minute_desc = f"每{interval}分钟"
elif "," in minute:
minute_desc = f"在第{minute}分钟"
else:
minute_desc = f"在第{minute}分钟"
# 分析小时
if hour == "*":
hour_desc = "每小时"
elif hour.startswith("*/"):
interval = hour[2:]
hour_desc = f"每{interval}小时"
elif "," in hour:
hour_desc = f"在{hour}点"
else:
hour_desc = f"在{hour}点"
# 分析日期
if day == "*":
day_desc = "每天"
elif day.startswith("*/"):
interval = day[2:]
day_desc = f"每{interval}天"
else:
day_desc = f"每月{day}号"
# 分析月份
if month == "*":
month_desc = "每月"
else:
month_desc = f"在{month}月"
# 分析星期
weekday_names = {
"0": "周日", "1": "周一", "2": "周二", "3": "周三",
"4": "周四", "5": "周五", "6": "周六", "7": "周日"
}
if weekday == "*":
weekday_desc = ""
else:
weekday_desc = f"在{weekday_names.get(weekday, weekday)}"
# 组合描述
if minute.startswith("*/") and hour == "*" and day == "*" and month == "*" and weekday == "*":
# 简单的间隔模式，如 */30 * * * *
return f"每{minute[2:]}分钟执行一次"
elif hour != "*" and minute != "*" and day == "*" and month == "*" and weekday == "*":
# 每天特定时间，如 0 9 * * *
return f"每天{hour}:{minute.zfill(2)}执行"
elif weekday != "*" and day == "*":
# 每周特定时间
return f"{weekday_desc}{hour}:{minute.zfill(2)}执行"
else:
# 复杂模式，显示详细信息
desc_parts = [part for part in [month_desc, day_desc, weekday_desc, hour_desc, minute_desc] if part and part != "每月" and part != "每天" and part != "每小时"]
if desc_parts:
return " ".join(desc_parts) + "执行"
else:
return f"复杂表达式: {cron_expr}"
except Exception as e:
return f"解析失败: {cron_expr}"
def show_status():
print("📊 容器状态:")
# 检查 PID 1 状态
supercronic_is_pid1 = False
pid1_cmdline = ""
try:
with open('/proc/1/cmdline', 'r') as f:
pid1_cmdline = f.read().replace('\x00', ' ').strip()
print(f" 🔍 PID 1 进程: {pid1_cmdline}")
if "supercronic" in pid1_cmdline.lower():
print(" ✅ supercronic 正确运行为 PID 1")
supercronic_is_pid1 = True
else:
print(" ❌ PID 1 不是 supercronic")
print(f" 📋 实际的 PID 1: {pid1_cmdline}")
except Exception as e:
print(f" ❌ 无法读取 PID 1 信息: {e}")
# 检查环境变量
cron_schedule = os.environ.get("CRON_SCHEDULE", "未设置")
run_mode = os.environ.get("RUN_MODE", "未设置")
immediate_run = os.environ.get("IMMEDIATE_RUN", "未设置")
print(f" ⚙️ 运行配置:")
print(f" CRON_SCHEDULE: {cron_schedule}")
# 解析并显示cron表达式的含义
cron_description = parse_cron_schedule(cron_schedule)
print(f" ⏰ 执行频率: {cron_description}")
print(f" RUN_MODE: {run_mode}")
print(f" IMMEDIATE_RUN: {immediate_run}")
# 检查配置文件
config_files = ["/app/config/config.yaml", "/app/config/frequency_words.txt"]
print(" 📁 配置文件:")
for file_path in config_files:
if Path(file_path).exists():
print(f" ✅ {Path(file_path).name}")
else:
print(f" ❌ {Path(file_path).name} 缺失")
# 检查关键文件
key_files = [
("/usr/local/bin/supercronic-linux-amd64", "supercronic二进制文件"),
("/usr/local/bin/supercronic", "supercronic软链接"),
("/tmp/crontab", "crontab文件"),
("/entrypoint.sh", "启动脚本")
]
print(" 📂 关键文件检查:")
for file_path, description in key_files:
if Path(file_path).exists():
print(f" ✅ {description}: 存在")
# 对于crontab文件，显示内容
if file_path == "/tmp/crontab":
try:
with open(file_path, 'r') as f:
crontab_content = f.read().strip()
print(f" 内容: {crontab_content}")
except:
pass
else:
print(f" ❌ {description}: 不存在")
# 检查容器运行时间
print(" ⏱️ 容器时间信息:")
try:
# 检查 PID 1 的启动时间
with open('/proc/1/stat', 'r') as f:
stat_content = f.read().strip().split()
if len(stat_content) >= 22:
# starttime 是第22个字段（索引21）
starttime_ticks = int(stat_content[21])
# 读取系统启动时间
with open('/proc/stat', 'r') as stat_f:
for line in stat_f:
if line.startswith('btime'):
boot_time = int(line.split()[1])
break
else:
boot_time = 0
# 读取系统时钟频率
clock_ticks = os.sysconf(os.sysconf_names['SC_CLK_TCK'])
if boot_time > 0:
pid1_start_time = boot_time + (starttime_ticks / clock_ticks)
current_time = time.time()
uptime_seconds = int(current_time - pid1_start_time)
uptime_minutes = uptime_seconds // 60
uptime_hours = uptime_minutes // 60
if uptime_hours > 0:
print(f" PID 1 运行时间: {uptime_hours} 小时 {uptime_minutes % 60} 分钟")
else:
print(f" PID 1 运行时间: {uptime_minutes} 分钟 ({uptime_seconds} 秒)")
else:
print(f" PID 1 运行时间: 无法精确计算")
else:
print(" ❌ 无法解析 PID 1 统计信息")
except Exception as e:
print(f" ❌ 时间检查失败: {e}")
# 状态总结和建议
print(" 📊 状态总结:")
if supercronic_is_pid1:
print(" ✅ supercronic 正确运行为 PID 1")
print(" ✅ 定时任务应该正常工作")
# 显示当前的调度信息
if cron_schedule != "未设置":
print(f" ⏰ 当前调度: {cron_description}")
# 提供一些常见的调度建议
if "分钟" in cron_description and "每30分钟" not in cron_description and "每60分钟" not in cron_description:
print(" 💡 频繁执行模式，适合实时监控")
elif "小时" in cron_description:
print(" 💡 按小时执行模式，适合定期汇总")
elif "天" in cron_description:
print(" 💡 每日执行模式，适合日报生成")
print(" 💡 如果定时任务不执行，检查:")
print(" • crontab 格式是否正确")
print(" • 时区设置是否正确")
print(" • 应用程序是否有错误")
else:
print(" ❌ supercronic 状态异常")
if pid1_cmdline:
print(f" 📋 当前 PID 1: {pid1_cmdline}")
print(" 💡 建议操作:")
print(" • 重启容器: docker restart trendradar")
print(" • 检查容器日志: docker logs trendradar")
# 显示日志检查建议
print(" 📋 运行状态检查:")
print(" • 查看完整容器日志: docker logs trendradar")
print(" • 查看实时日志: docker logs -f trendradar")
print(" • 手动执行测试: python manage.py run")
print(" • 重启容器服务: docker restart trendradar")
def show_config():
print("⚙️ 当前配置:")
env_vars = [
# 运行配置
"CRON_SCHEDULE",
"RUN_MODE",
"IMMEDIATE_RUN",
# 通知渠道
"FEISHU_WEBHOOK_URL",
"DINGTALK_WEBHOOK_URL",
"WEWORK_WEBHOOK_URL",
"WEWORK_MSG_TYPE",
"TELEGRAM_BOT_TOKEN",
"TELEGRAM_CHAT_ID",
"NTFY_SERVER_URL",
"NTFY_TOPIC",
"NTFY_TOKEN",
"BARK_URL",
"SLACK_WEBHOOK_URL",
# AI 分析配置
"AI_ANALYSIS_ENABLED",
"AI_API_KEY",
"AI_PROVIDER",
"AI_MODEL",
"AI_BASE_URL",
# 远程存储配置
"S3_BUCKET_NAME",
"S3_ACCESS_KEY_ID",
"S3_ENDPOINT_URL",
"S3_REGION",
]
for var in env_vars:
value = os.environ.get(var, "未设置")
# 隐藏敏感信息
if any(sensitive in var for sensitive in ["WEBHOOK", "TOKEN", "KEY", "SECRET"]):
if value and value != "未设置":
masked_value = value[:10] + "***" if len(value) > 10 else "***"
print(f" {var}: {masked_value}")
else:
print(f" {var}: {value}")
else:
print(f" {var}: {value}")
crontab_file = "/tmp/crontab"
if Path(crontab_file).exists():
print(" 📅 Crontab内容:")
try:
with open(crontab_file, "r") as f:
content = f.read().strip()
print(f" {content}")
except Exception as e:
print(f" 读取失败: {e}")
else:
print(" 📅 Crontab文件不存在")
def show_files():
print("📁 输出文件:")
output_dir = Path("/app/output")
if not output_dir.exists():
print(" 📭 输出目录不存在")
return
# 新结构：扁平化目录
# - output/news/*.db
# - output/rss/*.db
# - output/txt/{date}/*.txt
# - output/html/{date}/*.html
# 检查 news 数据库
news_dir = output_dir / "news"
if news_dir.exists():
db_files = sorted(news_dir.glob("*.db"), key=lambda x: x.name, reverse=True)
if db_files:
print(f" 💾 热榜数据库 (news/): {len(db_files)} 个")
for db_file in db_files[:5]:
mtime = time.ctime(db_file.stat().st_mtime)
size_kb = db_file.stat().st_size // 1024
print(f" 📀 {db_file.name} ({size_kb}KB, {mtime.split()[3][:5]})")
if len(db_files) > 5:
print(f" ... 还有 {len(db_files) - 5} 个")
# 检查 RSS 数据库
rss_dir = output_dir / "rss"
if rss_dir.exists():
db_files = sorted(rss_dir.glob("*.db"), key=lambda x: x.name, reverse=True)
if db_files:
print(f" 📰 RSS 数据库 (rss/): {len(db_files)} 个")
for db_file in db_files[:5]:
mtime = time.ctime(db_file.stat().st_mtime)
size_kb = db_file.stat().st_size // 1024
print(f" 📀 {db_file.name} ({size_kb}KB, {mtime.split()[3][:5]})")
if len(db_files) > 5:
print(f" ... 还有 {len(db_files) - 5} 个")
# 检查 TXT 快照目录
txt_dir = output_dir / "txt"
if txt_dir.exists():
date_dirs = sorted([d for d in txt_dir.iterdir() if d.is_dir()], reverse=True)
if date_dirs:
print(f" 📄 TXT 快照 (txt/): {len(date_dirs)} 天")
for date_dir in date_dirs[:3]:
txt_files = list(date_dir.glob("*.txt"))
if txt_files:
recent = sorted(txt_files, key=lambda x: x.stat().st_mtime, reverse=True)[0]
mtime = time.ctime(recent.stat().st_mtime)
print(f" 📅 {date_dir.name}: {len(txt_files)} 个文件 (最新: {mtime.split()[3][:5]})")
# 检查 HTML 报告目录
html_dir = output_dir / "html"
if html_dir.exists():
date_dirs = sorted([d for d in html_dir.iterdir() if d.is_dir()], reverse=True)
if date_dirs:
print(f" 🌐 HTML 报告 (html/): {len(date_dirs)} 天")
for date_dir in date_dirs[:3]:
html_files = list(date_dir.glob("*.html"))
if html_files:
recent = sorted(html_files, key=lambda x: x.stat().st_mtime, reverse=True)[0]
mtime = time.ctime(recent.stat().st_mtime)
print(f" 📅 {date_dir.name}: {len(html_files)} 个文件 (最新: {mtime.split()[3][:5]})")
def show_logs():
print("📋 实时日志 (按 Ctrl+C 退出):")
print("💡 提示: 这将显示 PID 1 进程的输出")
try:
# 尝试多种方法查看日志
log_files = [
"/proc/1/fd/1", # PID 1 的标准输出
"/proc/1/fd/2", # PID 1 的标准错误
]
for log_file in log_files:
if Path(log_file).exists():
print(f"📄 尝试读取: {log_file}")
subprocess.run(["tail", "-f", log_file], check=True)
break
else:
print("📋 无法找到标准日志文件，建议使用: docker logs trendradar")
except KeyboardInterrupt:
print("\n👋 退出日志查看")
except Exception as e:
print(f"❌ 查看日志失败: {e}")
print("💡 建议使用: docker logs trendradar")
def restart_supercronic():
print("🔄 重启supercronic...")
print("⚠️ 注意: supercronic 是 PID 1，无法直接重启")
# 检查当前 PID 1
try:
with open('/proc/1/cmdline', 'r') as f:
pid1_cmdline = f.read().replace('\x00', ' ').strip()
print(f" 🔍 当前 PID 1: {pid1_cmdline}")
if "supercronic" in pid1_cmdline.lower():
print(" ✅ PID 1 是 supercronic")
print(" 💡 要重启 supercronic，需要重启整个容器:")
print(" docker restart trendradar")
else:
print(" ❌ PID 1 不是 supercronic，这是异常状态")
print(" 💡 建议重启容器以修复问题:")
print(" docker restart trendradar")
except Exception as e:
print(f" ❌ 无法检查 PID 1: {e}")
print(" 💡 建议重启容器: docker restart trendradar")
def _read_proc_cmdline(pid: int) -> str:
proc_cmdline = Path(f"/proc/{pid}/cmdline")
if not proc_cmdline.exists():
return ""
try:
with open(proc_cmdline, "rb") as f:
return f.read().replace(b"\x00", b" ").decode("utf-8", errors="ignore").strip()
except Exception:
return ""
def _is_expected_webserver_process(pid: int) -> bool:
cmdline = _read_proc_cmdline(pid)
if not cmdline:
return False
return "http.server" in cmdline and str(WEBSERVER_PORT) in cmdline
def _is_manual_stop_requested() -> bool:
return Path(WEBSERVER_MANUAL_STOP_FILE).exists()
def _set_manual_stop_marker():
try:
with open(WEBSERVER_MANUAL_STOP_FILE, "w", encoding="utf-8") as f:
f.write(get_timestamp())
except Exception:
pass
def _clear_manual_stop_marker():
try:
if Path(WEBSERVER_MANUAL_STOP_FILE).exists():
os.remove(WEBSERVER_MANUAL_STOP_FILE)
except Exception:
pass
def _terminate_webserver_process(pid: int, require_expected: bool = True) -> bool:
try:
os.kill(pid, 0)
except OSError:
return True
if require_expected and not _is_expected_webserver_process(pid):
print(f" ⚠️ PID {pid} 存在但并非 Web 服务器进程，跳过终止")
return False
try:
os.kill(pid, signal.SIGTERM)
time.sleep(0.5)
try:
os.kill(pid, 0)
os.kill(pid, signal.SIGKILL)
print(f" ⚠️ 强制停止 Web 服务器 (PID: {pid})")
except OSError:
print(f" ✅ Web 服务器已停止 (PID: {pid})")
return True
except OSError:
return True
def _is_webserver_running(pid: int) -> bool:
try:
os.kill(pid, 0)
except OSError:
return False
if not _is_expected_webserver_process(pid):
return False
try:
import urllib.request
req = urllib.request.Request(f"http://127.0.0.1:{WEBSERVER_PORT}/", method="HEAD")
urllib.request.urlopen(req, timeout=3)
return True
except Exception:
try:
time.sleep(1)
import urllib.request
req = urllib.request.Request(f"http://127.0.0.1:{WEBSERVER_PORT}/", method="HEAD")
urllib.request.urlopen(req, timeout=3)
return True
except Exception:
return False
def _cleanup_stale_pid():
if not Path(WEBSERVER_PID_FILE).exists():
return False
try:
with open(WEBSERVER_PID_FILE, 'r') as f:
old_pid = int(f.read().strip())
os.remove(WEBSERVER_PID_FILE)
print(f" 🧹 清理失效 PID 文件 (PID: {old_pid})")
return True
except Exception:
return False
def start_webserver(force: bool = False):
print(f"🌐 启动 Web 服务器 (端口: {WEBSERVER_PORT})...")
print(f" 🔒 安全提示：仅提供静态文件访问，限制在 {WEBSERVER_DIR} 目录")
if force:
_clear_manual_stop_marker()
elif _is_manual_stop_requested():
print(" ℹ️ 检测到手动停服标记，跳过自动启动")
return
# 检查是否已经运行
if Path(WEBSERVER_PID_FILE).exists():
try:
with open(WEBSERVER_PID_FILE, 'r') as f:
old_pid = int(f.read().strip())
# 使用增强的进程检查
if _is_webserver_running(old_pid):
print(f" ⚠️ Web 服务器已在运行 (PID: {old_pid})")
print(f" 💡 访问: http://localhost:{WEBSERVER_PORT}")
print(" 💡 停止服务: python manage.py stop_webserver")
return
# 进程异常时优先尝试终止旧进程，避免端口占用导致重启失败
_terminate_webserver_process(old_pid, require_expected=True)
_cleanup_stale_pid()
print(f" ℹ️ 检测到失效的 PID 文件，已清理")
except Exception as e:
print(f" ⚠️ 清理旧的 PID 文件: {e}")
_cleanup_stale_pid()
# 检查目录是否存在
if not Path(WEBSERVER_DIR).exists():
print(f" ❌ 目录不存在: {WEBSERVER_DIR}")
return
try:
# 启动 HTTP 服务器
# 使用 --bind 绑定到 0.0.0.0 使容器内部可访问
# 工作目录限制在 WEBSERVER_DIR，防止访问其他目录
process = subprocess.Popen(
[sys.executable, '-m', 'http.server', str(WEBSERVER_PORT), '--bind', '0.0.0.0'],
cwd=WEBSERVER_DIR,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
start_new_session=True
)
# 等待一下确保服务器启动
time.sleep(1)
# 检查进程是否还在运行
if process.poll() is None:
# 保存 PID
with open(WEBSERVER_PID_FILE, 'w') as f:
f.write(str(process.pid))
_clear_manual_stop_marker()
print(f" ✅ Web 服务器已启动 (PID: {process.pid})")
print(f" 📁 服务目录: {WEBSERVER_DIR} (只读，仅静态文件)")
print(f" 🌐 访问地址: http://localhost:{WEBSERVER_PORT}")
print(f" 📄 首页: http://localhost:{WEBSERVER_PORT}/index.html")
print(" 💡 停止服务: python manage.py stop_webserver")
else:
print(f" ❌ Web 服务器启动失败")
except Exception as e:
print(f" ❌ 启动失败: {e}")
def stop_webserver():
print("🛑 停止 Web 服务器...")
_set_manual_stop_marker()
if not Path(WEBSERVER_PID_FILE).exists():
print(" ℹ️ Web 服务器未运行")
print(" ℹ️ 已写入手动停服标记，watchdog 不会自动拉起")
return
try:
with open(WEBSERVER_PID_FILE, 'r') as f:
pid = int(f.read().strip())
_terminate_webserver_process(pid, require_expected=True)
if Path(WEBSERVER_PID_FILE).exists():
os.remove(WEBSERVER_PID_FILE)
print(" ℹ️ 已写入手动停服标记，watchdog 不会自动拉起")
except Exception as e:
print(f" ❌ 停止失败: {e}")
# 尝试清理 PID 文件
try:
os.remove(WEBSERVER_PID_FILE)
except:
pass
def webserver_status():
print("🌐 Web 服务器状态:")
if not Path(WEBSERVER_PID_FILE).exists():
print(" ⭕ 未运行")
if _is_manual_stop_requested():
print(" ℹ️ 当前为手动停服状态，watchdog 不会自动拉起")
print(f" 💡 启动服务: python manage.py start_webserver")
return
try:
with open(WEBSERVER_PID_FILE, 'r') as f:
pid = int(f.read().strip())
# 使用增强的进程检查
if _is_webserver_running(pid):
print(f" ✅ 运行中 (PID: {pid})")
print(f" 📁 服务目录: {WEBSERVER_DIR}")
print(f" 🌐 访问地址: http://localhost:{WEBSERVER_PORT}")
print(f" 📄 首页: http://localhost:{WEBSERVER_PORT}/index.html")
print(" 💡 停止服务: python manage.py stop_webserver")
else:
print(f" ⭕ 未运行 (PID 文件存在但进程不可用)")
_cleanup_stale_pid()
print(" 💡 启动服务: python manage.py start_webserver")
except Exception as e:
print(f" ❌ 状态检查失败: {e}")
def webserver_autofix():
if _is_manual_stop_requested():
if WEBSERVER_AUTOFIX_LOG_HEALTHY:
print(f"[{get_timestamp()}] ℹ️ 手动停服状态，跳过自动修复")
return
if not Path(WEBSERVER_PID_FILE).exists():
print(f"[{get_timestamp()}] ℹ️ Web 服务器未运行，启动中...")
start_webserver(force=False)
return
try:
with open(WEBSERVER_PID_FILE, 'r') as f:
pid = int(f.read().strip())
# 使用增强检查
if not _is_webserver_running(pid):
print(f"[{get_timestamp()}] ⚠️ Web 服务器不可用 (PID: {pid})，尝试重启...")
_terminate_webserver_process(pid, require_expected=True)
_cleanup_stale_pid()
start_webserver(force=False)
return
if WEBSERVER_AUTOFIX_LOG_HEALTHY:
print(f"[{get_timestamp()}] ✅ Web 服务器健康 (PID: {pid})")
except Exception as e:
print(f"[{get_timestamp()}] ❌ 健康检查异常: {e}")
_cleanup_stale_pid()
start_webserver(force=False)
def show_help():
help_text = """
🐳 TrendRadar 容器管理工具
📋 命令列表:
run - 手动执行一次爬虫
status - 显示容器运行状态
config - 显示当前配置
files - 显示输出文件
logs - 实时查看日志
restart - 重启说明
start_webserver - 启动 Web 服务器托管 output 目录
stop_webserver - 停止 Web 服务器
webserver_status - 查看 Web 服务器状态
help - 显示此帮助
📖 使用示例:
# 在容器中执行
python manage.py run
python manage.py status
python manage.py logs
python manage.py start_webserver
# 在宿主机执行
docker exec -it trendradar python manage.py run
docker exec -it trendradar python manage.py status
docker exec -it trendradar python manage.py start_webserver
docker logs trendradar
💡 常用操作指南:
1. 检查运行状态: status
- 查看 supercronic 是否为 PID 1
- 检查配置文件和关键文件
- 查看 cron 调度设置
2. 手动执行测试: run
- 立即执行一次新闻爬取
- 测试程序是否正常工作
3. 查看日志: logs
- 实时监控运行情况
- 也可使用: docker logs trendradar
4. 重启服务: restart
- 由于 supercronic 是 PID 1，需要重启整个容器
- 使用: docker restart trendradar
5. Web 服务器管理:
- 启动: start_webserver
- 停止: stop_webserver（写入手动停服标记，watchdog 不自动拉起）
- 状态: webserver_status
- 访问: http://localhost:8080
"""
print(help_text)
def main():
if len(sys.argv) < 2:
show_help()
return
command = sys.argv[1]
commands = {
"run": manual_run,
"status": show_status,
"config": show_config,
"files": show_files,
"logs": show_logs,
"restart": restart_supercronic,
"start_webserver": lambda: start_webserver(force=True),
"stop_webserver": stop_webserver,
"webserver_status": webserver_status,
"webserver_autofix": webserver_autofix,
"help": show_help,
}
if command in commands:
try:
commands[command]()
except KeyboardInterrupt:
print("\n👋 操作已取消")
except Exception as e:
print(f"❌ 执行出错: {e}")
else:
print(f"❌ 未知命令: {command}")
print("运行 'python manage.py help' 查看可用命令")
if __name__ == "__main__":
main() | --- +++ @@ -1,5 +1,8 @@ #!/usr/bin/env python3
# -*- coding: utf-8 -*-
+"""
+新闻爬虫容器管理工具 - supercronic
+"""
import os
import sys
@@ -17,6 +20,7 @@
def _env_bool(name: str, default: bool) -> bool:
+ """读取布尔环境变量，兼容 true/1/yes/on。"""
value = os.environ.get(name)
if value is None:
return default
@@ -27,10 +31,12 @@
def get_timestamp():
+ """获取当前时间戳字符串"""
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def run_command(cmd, shell=True, capture_output=True):
+ """执行系统命令"""
try:
result = subprocess.run(
cmd, shell=shell, capture_output=capture_output, text=True
@@ -41,6 +47,7 @@
def manual_run():
+ """手动执行一次爬虫"""
print("🔄 手动执行爬虫...")
try:
result = subprocess.run(
@@ -55,6 +62,7 @@
def parse_cron_schedule(cron_expr):
+ """解析cron表达式并返回人类可读的描述"""
if not cron_expr or cron_expr == "未设置":
return "未设置"
@@ -135,6 +143,7 @@
def show_status():
+ """显示容器状态"""
print("📊 容器状态:")
# 检查 PID 1 状态
@@ -280,6 +289,7 @@
def show_config():
+ """显示当前配置"""
print("⚙️ 当前配置:")
env_vars = [
@@ -338,6 +348,7 @@
def show_files():
+ """显示输出文件"""
print("📁 输出文件:")
output_dir = Path("/app/output")
@@ -405,6 +416,7 @@
def show_logs():
+ """显示实时日志"""
print("📋 实时日志 (按 Ctrl+C 退出):")
print("💡 提示: 这将显示 PID 1 进程的输出")
try:
@@ -430,6 +442,7 @@
def restart_supercronic():
+ """重启supercronic进程"""
print("🔄 重启supercronic...")
print("⚠️ 注意: supercronic 是 PID 1，无法直接重启")
@@ -453,6 +466,7 @@
def _read_proc_cmdline(pid: int) -> str:
+ """读取进程 cmdline，失败时返回空字符串。"""
proc_cmdline = Path(f"/proc/{pid}/cmdline")
if not proc_cmdline.exists():
return ""
@@ -464,6 +478,7 @@
def _is_expected_webserver_process(pid: int) -> bool:
+ """检查 pid 是否是当前端口的 http.server 进程。"""
cmdline = _read_proc_cmdline(pid)
if not cmdline:
return False
@@ -471,10 +486,12 @@
def _is_manual_stop_requested() -> bool:
+ """是否处于手动停服状态。"""
return Path(WEBSERVER_MANUAL_STOP_FILE).exists()
def _set_manual_stop_marker():
+ """写入手动停服标记，防止 watchdog 自动拉起。"""
try:
with open(WEBSERVER_MANUAL_STOP_FILE, "w", encoding="utf-8") as f:
f.write(get_timestamp())
@@ -483,6 +500,7 @@
def _clear_manual_stop_marker():
+ """清理手动停服标记。"""
try:
if Path(WEBSERVER_MANUAL_STOP_FILE).exists():
os.remove(WEBSERVER_MANUAL_STOP_FILE)
@@ -491,6 +509,10 @@
def _terminate_webserver_process(pid: int, require_expected: bool = True) -> bool:
+ """尝试终止 Web 服务器进程。
+
+ require_expected=True 时，仅终止确认是 http.server 的进程，避免误杀。
+ """
try:
os.kill(pid, 0)
except OSError:
@@ -515,6 +537,7 @@
def _is_webserver_running(pid: int) -> bool:
+ """检查 Web 服务器进程是否真正在运行。"""
try:
os.kill(pid, 0)
except OSError:
@@ -540,6 +563,7 @@
def _cleanup_stale_pid():
+ """清理失效的 PID 文件"""
if not Path(WEBSERVER_PID_FILE).exists():
return False
@@ -554,6 +578,7 @@
def start_webserver(force: bool = False):
+ """启动 Web 服务器托管 output 目录"""
print(f"🌐 启动 Web 服务器 (端口: {WEBSERVER_PORT})...")
print(f" 🔒 安全提示：仅提供静态文件访问，限制在 {WEBSERVER_DIR} 目录")
@@ -624,6 +649,7 @@
def stop_webserver():
+ """停止 Web 服务器"""
print("🛑 停止 Web 服务器...")
_set_manual_stop_marker()
@@ -649,6 +675,7 @@
def webserver_status():
+ """查看 Web 服务器状态"""
print("🌐 Web 服务器状态:")
if not Path(WEBSERVER_PID_FILE).exists():
@@ -678,6 +705,11 @@
def webserver_autofix():
+ """Web 服务器健康检查和自动修复
+
+ 供 watchdog/定时任务调用，检查服务状态并在需要时自动重启。
+ 输出日志格式便于外部监控系统解析。
+ """
if _is_manual_stop_requested():
if WEBSERVER_AUTOFIX_LOG_HEALTHY:
print(f"[{get_timestamp()}] ℹ️ 手动停服状态，跳过自动修复")
@@ -710,6 +742,7 @@
def show_help():
+ """显示帮助信息"""
help_text = """
🐳 TrendRadar 容器管理工具
@@ -798,4 +831,4 @@
if __name__ == "__main__":
- main()+ main()
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/docker/manage.py |
Create documentation strings for testing functions | from langchain_core.messages import HumanMessage
from src.graph.state import AgentState, show_agent_reasoning
from src.utils.progress import progress
from src.tools.api import get_prices, prices_to_df
import json
import numpy as np
import pandas as pd
from src.utils.api_key import get_api_key_from_state
##### Risk Management Agent #####
def risk_management_agent(state: AgentState, agent_id: str = "risk_management_agent"):
portfolio = state["data"]["portfolio"]
data = state["data"]
tickers = data["tickers"]
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
# Initialize risk analysis for each ticker
risk_analysis = {}
current_prices = {} # Store prices here to avoid redundant API calls
volatility_data = {} # Store volatility metrics
returns_by_ticker: dict[str, pd.Series] = {} # For correlation analysis
# First, fetch prices and calculate volatility for all relevant tickers
all_tickers = set(tickers) | set(portfolio.get("positions", {}).keys())
for ticker in all_tickers:
progress.update_status(agent_id, ticker, "Fetching price data and calculating volatility")
prices = get_prices(
ticker=ticker,
start_date=data["start_date"],
end_date=data["end_date"],
api_key=api_key,
)
if not prices:
progress.update_status(agent_id, ticker, "Warning: No price data found")
volatility_data[ticker] = {
"daily_volatility": 0.05, # Default fallback volatility (5% daily)
"annualized_volatility": 0.05 * np.sqrt(252),
"volatility_percentile": 100, # Assume high risk if no data
"data_points": 0
}
continue
prices_df = prices_to_df(prices)
if not prices_df.empty and len(prices_df) > 1:
current_price = prices_df["close"].iloc[-1]
current_prices[ticker] = current_price
# Calculate volatility metrics
volatility_metrics = calculate_volatility_metrics(prices_df)
volatility_data[ticker] = volatility_metrics
# Store returns for correlation analysis (use close-to-close returns)
daily_returns = prices_df["close"].pct_change().dropna()
if len(daily_returns) > 0:
returns_by_ticker[ticker] = daily_returns
progress.update_status(
agent_id,
ticker,
f"Price: {current_price:.2f}, Ann. Vol: {volatility_metrics['annualized_volatility']:.1%}"
)
else:
progress.update_status(agent_id, ticker, "Warning: Insufficient price data")
current_prices[ticker] = 0
volatility_data[ticker] = {
"daily_volatility": 0.05,
"annualized_volatility": 0.05 * np.sqrt(252),
"volatility_percentile": 100,
"data_points": len(prices_df) if not prices_df.empty else 0
}
# Build returns DataFrame aligned across tickers for correlation analysis
correlation_matrix = None
if len(returns_by_ticker) >= 2:
try:
returns_df = pd.DataFrame(returns_by_ticker).dropna(how="any")
if returns_df.shape[1] >= 2 and returns_df.shape[0] >= 5:
correlation_matrix = returns_df.corr()
except Exception:
correlation_matrix = None
# Determine which tickers currently have exposure (non-zero absolute position)
active_positions = {
t for t, pos in portfolio.get("positions", {}).items()
if abs(pos.get("long", 0) - pos.get("short", 0)) > 0
}
# Calculate total portfolio value based on current market prices (Net Liquidation Value)
total_portfolio_value = portfolio.get("cash", 0.0)
for ticker, position in portfolio.get("positions", {}).items():
if ticker in current_prices:
# Add market value of long positions
total_portfolio_value += position.get("long", 0) * current_prices[ticker]
# Subtract market value of short positions
total_portfolio_value -= position.get("short", 0) * current_prices[ticker]
progress.update_status(agent_id, None, f"Total portfolio value: {total_portfolio_value:.2f}")
# Calculate volatility- and correlation-adjusted risk limits for each ticker
for ticker in tickers:
progress.update_status(agent_id, ticker, "Calculating volatility- and correlation-adjusted limits")
if ticker not in current_prices or current_prices[ticker] <= 0:
progress.update_status(agent_id, ticker, "Failed: No valid price data")
risk_analysis[ticker] = {
"remaining_position_limit": 0.0,
"current_price": 0.0,
"reasoning": {
"error": "Missing price data for risk calculation"
}
}
continue
current_price = current_prices[ticker]
vol_data = volatility_data.get(ticker, {})
# Calculate current market value of this position
position = portfolio.get("positions", {}).get(ticker, {})
long_value = position.get("long", 0) * current_price
short_value = position.get("short", 0) * current_price
current_position_value = abs(long_value - short_value) # Use absolute exposure
# Volatility-adjusted limit pct
vol_adjusted_limit_pct = calculate_volatility_adjusted_limit(
vol_data.get("annualized_volatility", 0.25)
)
# Correlation adjustment
corr_metrics = {
"avg_correlation_with_active": None,
"max_correlation_with_active": None,
"top_correlated_tickers": [],
}
corr_multiplier = 1.0
if correlation_matrix is not None and ticker in correlation_matrix.columns:
# Compute correlations with active positions (exclude self)
comparable = [t for t in active_positions if t in correlation_matrix.columns and t != ticker]
if not comparable:
# If no active positions, compare with all other available tickers
comparable = [t for t in correlation_matrix.columns if t != ticker]
if comparable:
series = correlation_matrix.loc[ticker, comparable]
# Drop NaNs just in case
series = series.dropna()
if len(series) > 0:
avg_corr = float(series.mean())
max_corr = float(series.max())
corr_metrics["avg_correlation_with_active"] = avg_corr
corr_metrics["max_correlation_with_active"] = max_corr
# Top 3 most correlated tickers
top_corr = series.sort_values(ascending=False).head(3)
corr_metrics["top_correlated_tickers"] = [
{"ticker": idx, "correlation": float(val)} for idx, val in top_corr.items()
]
corr_multiplier = calculate_correlation_multiplier(avg_corr)
# Combine volatility and correlation adjustments
combined_limit_pct = vol_adjusted_limit_pct * corr_multiplier
# Convert to dollar position limit
position_limit = total_portfolio_value * combined_limit_pct
# Calculate remaining limit for this position
remaining_position_limit = position_limit - current_position_value
# Ensure we don't exceed available cash
max_position_size = min(remaining_position_limit, portfolio.get("cash", 0))
risk_analysis[ticker] = {
"remaining_position_limit": float(max_position_size),
"current_price": float(current_price),
"volatility_metrics": {
"daily_volatility": float(vol_data.get("daily_volatility", 0.05)),
"annualized_volatility": float(vol_data.get("annualized_volatility", 0.25)),
"volatility_percentile": float(vol_data.get("volatility_percentile", 100)),
"data_points": int(vol_data.get("data_points", 0))
},
"correlation_metrics": corr_metrics,
"reasoning": {
"portfolio_value": float(total_portfolio_value),
"current_position_value": float(current_position_value),
"base_position_limit_pct": float(vol_adjusted_limit_pct),
"correlation_multiplier": float(corr_multiplier),
"combined_position_limit_pct": float(combined_limit_pct),
"position_limit": float(position_limit),
"remaining_limit": float(remaining_position_limit),
"available_cash": float(portfolio.get("cash", 0)),
"risk_adjustment": f"Volatility x Correlation adjusted: {combined_limit_pct:.1%} (base {vol_adjusted_limit_pct:.1%})"
},
}
progress.update_status(
agent_id,
ticker,
f"Adj. limit: {combined_limit_pct:.1%}, Available: ${max_position_size:.0f}"
)
progress.update_status(agent_id, None, "Done")
message = HumanMessage(
content=json.dumps(risk_analysis),
name=agent_id,
)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning(risk_analysis, "Volatility-Adjusted Risk Management Agent")
# Add the signal to the analyst_signals list
state["data"]["analyst_signals"][agent_id] = risk_analysis
return {
"messages": state["messages"] + [message],
"data": data,
}
def calculate_volatility_metrics(prices_df: pd.DataFrame, lookback_days: int = 60) -> dict:
if len(prices_df) < 2:
return {
"daily_volatility": 0.05,
"annualized_volatility": 0.05 * np.sqrt(252),
"volatility_percentile": 100,
"data_points": len(prices_df)
}
# Calculate daily returns
daily_returns = prices_df["close"].pct_change().dropna()
if len(daily_returns) < 2:
return {
"daily_volatility": 0.05,
"annualized_volatility": 0.05 * np.sqrt(252),
"volatility_percentile": 100,
"data_points": len(daily_returns)
}
# Use the most recent lookback_days for volatility calculation
recent_returns = daily_returns.tail(min(lookback_days, len(daily_returns)))
# Calculate volatility metrics
daily_vol = recent_returns.std()
annualized_vol = daily_vol * np.sqrt(252) # Annualize assuming 252 trading days
# Calculate percentile rank of recent volatility vs historical volatility
if len(daily_returns) >= 30: # Need sufficient history for percentile calculation
# Calculate 30-day rolling volatility for the full history
rolling_vol = daily_returns.rolling(window=30).std().dropna()
if len(rolling_vol) > 0:
# Compare current volatility against historical rolling volatilities
current_vol_percentile = (rolling_vol <= daily_vol).mean() * 100
else:
current_vol_percentile = 50 # Default to median
else:
current_vol_percentile = 50 # Default to median if insufficient data
return {
"daily_volatility": float(daily_vol) if not np.isnan(daily_vol) else 0.025,
"annualized_volatility": float(annualized_vol) if not np.isnan(annualized_vol) else 0.25,
"volatility_percentile": float(current_vol_percentile) if not np.isnan(current_vol_percentile) else 50.0,
"data_points": len(recent_returns)
}
def calculate_volatility_adjusted_limit(annualized_volatility: float) -> float:
base_limit = 0.20 # 20% baseline
if annualized_volatility < 0.15: # Low volatility
# Allow higher allocation for stable stocks
vol_multiplier = 1.25 # Up to 25%
elif annualized_volatility < 0.30: # Medium volatility
# Standard allocation with slight adjustment based on volatility
vol_multiplier = 1.0 - (annualized_volatility - 0.15) * 0.5 # 20% -> 12.5%
elif annualized_volatility < 0.50: # High volatility
# Reduce allocation significantly
vol_multiplier = 0.75 - (annualized_volatility - 0.30) * 0.5 # 15% -> 5%
else: # Very high volatility (>50%)
# Minimum allocation for very risky stocks
vol_multiplier = 0.50 # Max 10%
# Apply bounds to ensure reasonable limits
vol_multiplier = max(0.25, min(1.25, vol_multiplier)) # 5% to 25% range
return base_limit * vol_multiplier
def calculate_correlation_multiplier(avg_correlation: float) -> float:
if avg_correlation >= 0.80:
return 0.70
if avg_correlation >= 0.60:
return 0.85
if avg_correlation >= 0.40:
return 1.00
if avg_correlation >= 0.20:
return 1.05
return 1.10 | --- +++ @@ -9,6 +9,7 @@
##### Risk Management Agent #####
def risk_management_agent(state: AgentState, agent_id: str = "risk_management_agent"):
+ """Controls position sizing based on volatility-adjusted risk factors for multiple tickers."""
portfolio = state["data"]["portfolio"]
data = state["data"]
tickers = data["tickers"]
@@ -219,6 +220,7 @@
def calculate_volatility_metrics(prices_df: pd.DataFrame, lookback_days: int = 60) -> dict:
+ """Calculate comprehensive volatility metrics from price data."""
if len(prices_df) < 2:
return {
"daily_volatility": 0.05,
@@ -266,6 +268,15 @@
def calculate_volatility_adjusted_limit(annualized_volatility: float) -> float:
+ """
+ Calculate position limit as percentage of portfolio based on volatility.
+
+ Logic:
+ - Low volatility (<15%): Up to 25% allocation
+ - Medium volatility (15-30%): 15-20% allocation
+ - High volatility (>30%): 10-15% allocation
+ - Very high volatility (>50%): Max 10% allocation
+ """
base_limit = 0.20 # 20% baseline
if annualized_volatility < 0.15: # Low volatility
@@ -288,6 +299,13 @@
def calculate_correlation_multiplier(avg_correlation: float) -> float:
+ """Map average correlation to an adjustment multiplier.
+ - Very high correlation (>= 0.8): reduce limit sharply (0.7x)
+ - High correlation (0.6-0.8): reduce (0.85x)
+ - Moderate correlation (0.4-0.6): neutral (1.0x)
+ - Low correlation (0.2-0.4): slight increase (1.05x)
+ - Very low correlation (< 0.2): increase (1.10x)
+ """
if avg_correlation >= 0.80:
return 0.70
if avg_correlation >= 0.60:
@@ -296,4 +314,4 @@ return 1.00
if avg_correlation >= 0.20:
return 1.05
- return 1.10+ return 1.10
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/risk_manager.py |
Write docstrings for this repository |
import asyncio
import json
from typing import List, Optional, Dict, Union
from fastmcp import FastMCP
from .tools.data_query import DataQueryTools
from .tools.analytics import AnalyticsTools
from .tools.search_tools import SearchTools
from .tools.config_mgmt import ConfigManagementTools
from .tools.system import SystemManagementTools
from .tools.storage_sync import StorageSyncTools
from .tools.article_reader import ArticleReaderTools
from .tools.notification import NotificationTools
from .utils.date_parser import DateParser
from .utils.errors import MCPError
# 创建 FastMCP 2.0 应用
mcp = FastMCP('trendradar-news')
# 全局工具实例（在第一次请求时初始化）
_tools_instances = {}
def _get_tools(project_root: Optional[str] = None):
if not _tools_instances:
_tools_instances['data'] = DataQueryTools(project_root)
_tools_instances['analytics'] = AnalyticsTools(project_root)
_tools_instances['search'] = SearchTools(project_root)
_tools_instances['config'] = ConfigManagementTools(project_root)
_tools_instances['system'] = SystemManagementTools(project_root)
_tools_instances['storage'] = StorageSyncTools(project_root)
_tools_instances['article'] = ArticleReaderTools(project_root)
_tools_instances['notification'] = NotificationTools(project_root)
return _tools_instances
# ==================== MCP Resources ====================
@mcp.resource("config://platforms")
async def get_platforms_resource() -> str:
tools = _get_tools()
config = await asyncio.to_thread(
tools['config'].get_current_config, section="crawler"
)
return json.dumps({
"platforms": config.get("platforms", []),
"description": "TrendRadar 支持的热榜平台列表"
}, ensure_ascii=False, indent=2)
@mcp.resource("config://rss-feeds")
async def get_rss_feeds_resource() -> str:
tools = _get_tools()
status = await asyncio.to_thread(tools['data'].get_rss_feeds_status)
return json.dumps({
"feeds": status.get("today_feeds", {}),
"description": "TrendRadar 支持的 RSS 订阅源列表"
}, ensure_ascii=False, indent=2)
@mcp.resource("data://available-dates")
async def get_available_dates_resource() -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['storage'].list_available_dates, source="local"
)
return json.dumps({
"dates": result.get("data", {}).get("local", {}).get("dates", []),
"description": "本地存储中可查询的日期列表"
}, ensure_ascii=False, indent=2)
@mcp.resource("config://keywords")
async def get_keywords_resource() -> str:
tools = _get_tools()
config = await asyncio.to_thread(
tools['config'].get_current_config, section="keywords"
)
return json.dumps({
"word_groups": config.get("word_groups", []),
"total_groups": config.get("total_groups", 0),
"description": "TrendRadar 关注词配置"
}, ensure_ascii=False, indent=2)
# ==================== 日期解析工具（优先调用）====================
@mcp.tool
async def resolve_date_range(
expression: str
) -> str:
try:
result = await asyncio.to_thread(DateParser.resolve_date_range_expression, expression)
return json.dumps(result, ensure_ascii=False, indent=2)
except MCPError as e:
return json.dumps({
"success": False,
"error": e.to_dict()
}, ensure_ascii=False, indent=2)
except Exception as e:
return json.dumps({
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}, ensure_ascii=False, indent=2)
# ==================== 数据查询工具 ====================
@mcp.tool
async def get_latest_news(
platforms: Optional[List[str]] = None,
limit: int = 50,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_latest_news,
platforms=platforms, limit=limit, include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_trending_topics(
top_n: int = 10,
mode: str = 'current',
extract_mode: str = 'keywords'
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_trending_topics,
top_n=top_n, mode=mode, extract_mode=extract_mode
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== RSS 数据查询工具 ====================
@mcp.tool
async def get_latest_rss(
feeds: Optional[List[str]] = None,
days: int = 1,
limit: int = 50,
include_summary: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_latest_rss,
feeds=feeds, days=days, limit=limit, include_summary=include_summary
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def search_rss(
keyword: str,
feeds: Optional[List[str]] = None,
days: int = 7,
limit: int = 50,
include_summary: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].search_rss,
keyword=keyword,
feeds=feeds,
days=days,
limit=limit,
include_summary=include_summary
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_rss_feeds_status() -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['data'].get_rss_feeds_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_news_by_date(
date_range: Optional[Union[Dict[str, str], str]] = None,
platforms: Optional[List[str]] = None,
limit: int = 50,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_news_by_date,
date_range=date_range,
platforms=platforms,
limit=limit,
include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 高级数据分析工具 ====================
@mcp.tool
async def analyze_topic_trend(
topic: str,
analysis_type: str = "trend",
date_range: Optional[Union[Dict[str, str], str]] = None,
granularity: str = "day",
spike_threshold: float = 3.0,
time_window: int = 24,
lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_topic_trend_unified,
topic=topic,
analysis_type=analysis_type,
date_range=date_range,
granularity=granularity,
threshold=spike_threshold,
time_window=time_window,
lookahead_hours=lookahead_hours,
confidence_threshold=confidence_threshold
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def analyze_data_insights(
insight_type: str = "platform_compare",
topic: Optional[str] = None,
date_range: Optional[Union[Dict[str, str], str]] = None,
min_frequency: int = 3,
top_n: int = 20
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_data_insights_unified,
insight_type=insight_type,
topic=topic,
date_range=date_range,
min_frequency=min_frequency,
top_n=top_n
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def analyze_sentiment(
topic: Optional[str] = None,
platforms: Optional[List[str]] = None,
date_range: Optional[Union[Dict[str, str], str]] = None,
limit: int = 50,
sort_by_weight: bool = True,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_sentiment,
topic=topic,
platforms=platforms,
date_range=date_range,
limit=limit,
sort_by_weight=sort_by_weight,
include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def find_related_news(
reference_title: str,
date_range: Optional[Union[Dict[str, str], str]] = None,
threshold: float = 0.5,
limit: int = 50,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['search'].find_related_news_unified,
reference_title=reference_title,
date_range=date_range,
threshold=threshold,
limit=limit,
include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def generate_summary_report(
report_type: str = "daily",
date_range: Optional[Union[Dict[str, str], str]] = None
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].generate_summary_report,
report_type=report_type,
date_range=date_range
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def aggregate_news(
date_range: Optional[Union[Dict[str, str], str]] = None,
platforms: Optional[List[str]] = None,
similarity_threshold: float = 0.7,
limit: int = 50,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].aggregate_news,
date_range=date_range,
platforms=platforms,
similarity_threshold=similarity_threshold,
limit=limit,
include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def compare_periods(
period1: Union[Dict[str, str], str],
period2: Union[Dict[str, str], str],
topic: Optional[str] = None,
compare_type: str = "overview",
platforms: Optional[List[str]] = None,
top_n: int = 10
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].compare_periods,
period1=period1,
period2=period2,
topic=topic,
compare_type=compare_type,
platforms=platforms,
top_n=top_n
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 智能检索工具 ====================
@mcp.tool
async def search_news(
query: str,
search_mode: str = "keyword",
date_range: Optional[Union[Dict[str, str], str]] = None,
platforms: Optional[List[str]] = None,
limit: int = 50,
sort_by: str = "relevance",
threshold: float = 0.6,
include_url: bool = False,
include_rss: bool = False,
rss_limit: int = 20
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['search'].search_news_unified,
query=query,
search_mode=search_mode,
date_range=date_range,
platforms=platforms,
limit=limit,
sort_by=sort_by,
threshold=threshold,
include_url=include_url,
include_rss=include_rss,
rss_limit=rss_limit
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 配置与系统管理工具 ====================
@mcp.tool
async def get_current_config(
section: str = "all"
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['config'].get_current_config, section=section)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_system_status() -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['system'].get_system_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def check_version(
proxy_url: Optional[str] = None
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['system'].check_version, proxy_url=proxy_url)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def trigger_crawl(
platforms: Optional[List[str]] = None,
save_to_local: bool = False,
include_url: bool = False
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['system'].trigger_crawl,
platforms=platforms, save_to_local=save_to_local, include_url=include_url
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 存储同步工具 ====================
@mcp.tool
async def sync_from_remote(
days: int = 7
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].sync_from_remote, days=days)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_storage_status() -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].get_storage_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def list_available_dates(
source: str = "both"
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].list_available_dates, source=source)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 文章内容读取工具 ====================
@mcp.tool
async def read_article(
url: str,
timeout: int = 30
) -> str:
tools = _get_tools()
timeout = min(max(timeout, 10), 60)
result = await asyncio.to_thread(
tools['article'].read_article,
url=url, timeout=timeout
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def read_articles_batch(
urls: List[str],
timeout: int = 30
) -> str:
tools = _get_tools()
timeout = min(max(timeout, 10), 60)
result = await asyncio.to_thread(
tools['article'].read_articles_batch,
urls=urls, timeout=timeout
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 通知推送工具 ====================
@mcp.tool
async def get_channel_format_guide(channel: Optional[str] = None) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['notification'].get_channel_format_guide,
channel=channel
)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def get_notification_channels() -> str:
tools = _get_tools()
result = await asyncio.to_thread(tools['notification'].get_notification_channels)
return json.dumps(result, ensure_ascii=False, indent=2)
@mcp.tool
async def send_notification(
message: str,
title: str = "TrendRadar 通知",
channels: Optional[List[str]] = None,
) -> str:
tools = _get_tools()
result = await asyncio.to_thread(
tools['notification'].send_notification,
message=message, title=title, channels=channels
)
return json.dumps(result, ensure_ascii=False, indent=2)
# ==================== 启动入口 ====================
def run_server(
project_root: Optional[str] = None,
transport: str = 'stdio',
host: str = '0.0.0.0',
port: int = 3333
):
# 初始化工具实例
_get_tools(project_root)
# 打印启动信息
print()
print("=" * 60)
print(" TrendRadar MCP Server - FastMCP 2.0")
print("=" * 60)
print(f" 传输模式: {transport.upper()}")
if transport == 'stdio':
print(" 协议: MCP over stdio (标准输入输出)")
print(" 说明: 通过标准输入输出与 MCP 客户端通信")
elif transport == 'http':
print(f" 协议: MCP over HTTP (生产环境)")
print(f" 服务器监听: {host}:{port}")
if project_root:
print(f" 项目目录: {project_root}")
else:
print(" 项目目录: 当前目录")
print()
print(" 已注册的工具:")
print(" === 日期解析工具（推荐优先调用）===")
print(" 0. resolve_date_range - 解析自然语言日期为标准格式")
print()
print(" === 基础数据查询（P0核心）===")
print(" 1. get_latest_news - 获取最新新闻")
print(" 2. get_news_by_date - 按日期查询新闻（支持自然语言）")
print(" 3. get_trending_topics - 获取趋势话题（支持自动提取）")
print()
print(" === RSS 数据查询 ===")
print(" 4. get_latest_rss - 获取最新 RSS 订阅数据")
print(" 5. search_rss - 搜索 RSS 数据")
print(" 6. get_rss_feeds_status - 获取 RSS 源状态")
print()
print(" === 智能检索工具 ===")
print(" 7. search_news - 统一新闻搜索（关键词/模糊/实体）")
print(" 8. find_related_news - 相关新闻查找（支持历史数据）")
print()
print(" === 高级数据分析 ===")
print(" 9. analyze_topic_trend - 统一话题趋势分析（热度/生命周期/爆火/预测）")
print(" 10. analyze_data_insights - 统一数据洞察分析（平台对比/活跃度/关键词共现）")
print(" 11. analyze_sentiment - 情感倾向分析")
print(" 12. aggregate_news - 跨平台新闻聚合去重")
print(" 13. compare_periods - 时期对比分析（周环比/月环比）")
print(" 14. generate_summary_report - 每日/每周摘要生成")
print()
print(" === 配置与系统管理 ===")
print(" 15. get_current_config - 获取当前系统配置")
print(" 16. get_system_status - 获取系统运行状态")
print(" 17. check_version - 检查版本更新（对比本地与远程版本）")
print(" 18. trigger_crawl - 手动触发爬取任务")
print()
print(" === 存储同步工具 ===")
print(" 19. sync_from_remote - 从远程存储拉取数据到本地")
print(" 20. get_storage_status - 获取存储配置和状态")
print(" 21. list_available_dates - 列出本地/远程可用日期")
print()
print(" === 文章内容读取 ===")
print(" 22. read_article - 读取单篇文章内容（Markdown格式）")
print(" 23. read_articles_batch - 批量读取多篇文章（自动限速）")
print()
print(" === 通知推送工具 ===")
print(" 24. get_channel_format_guide - 获取渠道格式化策略指南（提示词）")
print(" 25. get_notification_channels - 获取已配置的通知渠道状态")
print(" 26. send_notification - 向通知渠道发送消息（自动适配格式）")
print("=" * 60)
print()
# 根据传输模式运行服务器
if transport == 'stdio':
mcp.run(transport='stdio')
elif transport == 'http':
# HTTP 模式（生产推荐）
mcp.run(
transport='http',
host=host,
port=port,
path='/mcp' # HTTP 端点路径
)
else:
raise ValueError(f"不支持的传输模式: {transport}")
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser(
description='TrendRadar MCP Server - 新闻热点聚合 MCP 工具服务器',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
详细配置教程请查看: README-Cherry-Studio.md
"""
)
parser.add_argument(
'--transport',
choices=['stdio', 'http'],
default='stdio',
help='传输模式：stdio (默认) 或 http (生产环境)'
)
parser.add_argument(
'--host',
default='0.0.0.0',
help='HTTP模式的监听地址，默认 0.0.0.0'
)
parser.add_argument(
'--port',
type=int,
default=3333,
help='HTTP模式的监听端口，默认 3333'
)
parser.add_argument(
'--project-root',
help='项目根目录路径'
)
args = parser.parse_args()
run_server(
project_root=args.project_root,
transport=args.transport,
host=args.host,
port=args.port
) | --- +++ @@ -1,3 +1,9 @@+"""
+TrendRadar MCP Server - FastMCP 2.0 实现
+
+使用 FastMCP 2.0 提供生产级 MCP 工具服务器。
+支持 stdio 和 HTTP 两种传输模式。
+"""
import asyncio
import json
@@ -25,6 +31,7 @@
def _get_tools(project_root: Optional[str] = None):
+ """获取或创建工具实例（单例模式）"""
if not _tools_instances:
_tools_instances['data'] = DataQueryTools(project_root)
_tools_instances['analytics'] = AnalyticsTools(project_root)
@@ -41,6 +48,11 @@
@mcp.resource("config://platforms")
async def get_platforms_resource() -> str:
+ """
+ 获取支持的平台列表
+
+ 返回 config.yaml 中配置的所有平台信息，包括 ID 和名称。
+ """
tools = _get_tools()
config = await asyncio.to_thread(
tools['config'].get_current_config, section="crawler"
@@ -53,6 +65,11 @@
@mcp.resource("config://rss-feeds")
async def get_rss_feeds_resource() -> str:
+ """
+ 获取 RSS 订阅源列表
+
+ 返回当前配置的所有 RSS 源信息。
+ """
tools = _get_tools()
status = await asyncio.to_thread(tools['data'].get_rss_feeds_status)
return json.dumps({
@@ -63,6 +80,11 @@
@mcp.resource("data://available-dates")
async def get_available_dates_resource() -> str:
+ """
+ 获取可用的数据日期范围
+
+ 返回本地存储中可查询的日期列表。
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['storage'].list_available_dates, source="local"
@@ -75,6 +97,11 @@
@mcp.resource("config://keywords")
async def get_keywords_resource() -> str:
+ """
+ 获取关注词配置
+
+ 返回 frequency_words.txt 中配置的关注词分组。
+ """
tools = _get_tools()
config = await asyncio.to_thread(
tools['config'].get_current_config, section="keywords"
@@ -92,6 +119,53 @@ async def resolve_date_range(
expression: str
) -> str:
+ """
+ 【推荐优先调用】将自然语言日期表达式解析为标准日期范围
+
+ **为什么需要这个工具？**
+ 用户经常使用"本周"、"最近7天"等自然语言表达日期，但 AI 模型自己计算日期
+ 可能导致不一致的结果。此工具在服务器端使用精确的当前时间计算，确保所有
+ AI 模型获得一致的日期范围。
+
+ **推荐使用流程：**
+ 1. 用户说"分析AI本周的情感倾向"
+ 2. AI 调用 resolve_date_range("本周") → 获取精确日期范围
+ 3. AI 调用 analyze_sentiment(topic="ai", date_range=上一步返回的date_range)
+
+ Args:
+ expression: 自然语言日期表达式，支持：
+ - 单日: "今天", "昨天", "today", "yesterday"
+ - 周: "本周", "上周", "this week", "last week"
+ - 月: "本月", "上月", "this month", "last month"
+ - 最近N天: "最近7天", "最近30天", "last 7 days", "last 30 days"
+ - 动态: "最近5天", "last 10 days"（任意天数）
+
+ Returns:
+ JSON格式的日期范围，可直接用于其他工具的 date_range 参数：
+ {
+ "success": true,
+ "expression": "本周",
+ "date_range": {
+ "start": "2025-11-18",
+ "end": "2025-11-26"
+ },
+ "current_date": "2025-11-26",
+ "description": "本周（周一到周日，11-18 至 11-26）"
+ }
+
+ Examples:
+ 用户："分析AI本周的情感倾向"
+ AI调用步骤：
+ 1. resolve_date_range("本周")
+ → {"date_range": {"start": "2025-11-18", "end": "2025-11-26"}, ...}
+ 2. analyze_sentiment(topic="ai", date_range={"start": "2025-11-18", "end": "2025-11-26"})
+
+ 用户："看看最近7天的特斯拉新闻"
+ AI调用步骤：
+ 1. resolve_date_range("最近7天")
+ → {"date_range": {"start": "2025-11-20", "end": "2025-11-26"}, ...}
+ 2. search_news(query="特斯拉", date_range={"start": "2025-11-20", "end": "2025-11-26"})
+ """
try:
result = await asyncio.to_thread(DateParser.resolve_date_range_expression, expression)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -118,6 +192,22 @@ limit: int = 50,
include_url: bool = False
) -> str:
+ """
+ 获取最新一批爬取的新闻数据，快速了解当前热点
+
+ Args:
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ limit: 返回条数限制，默认50，最大1000
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ JSON格式的新闻列表
+
+ **数据展示建议**
+ - 默认展示全部返回数据，除非用户明确要求总结
+ - 用户说"总结"或"挑重点"时才进行筛选
+ - 用户问"为什么只显示部分"说明需要完整数据
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_latest_news,
@@ -132,6 +222,25 @@ mode: str = 'current',
extract_mode: str = 'keywords'
) -> str:
+ """
+ 获取热点话题统计
+
+ Args:
+ top_n: 返回TOP N话题，默认10
+ mode: 时间模式
+ - "daily": 当日累计数据统计
+ - "current": 最新一批数据统计（默认）
+ extract_mode: 提取模式
+ - "keywords": 统计预设关注词（基于 config/frequency_words.txt，默认）
+ - "auto_extract": 自动从新闻标题提取高频词（无需预设，自动发现热点）
+
+ Returns:
+ JSON格式的话题频率统计列表
+
+ Examples:
+ - 使用预设关注词: get_trending_topics(mode="current")
+ - 自动提取热点: get_trending_topics(extract_mode="auto_extract", top_n=20)
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_trending_topics,
@@ -149,6 +258,24 @@ limit: int = 50,
include_summary: bool = False
) -> str:
+ """
+ 获取最新的 RSS 订阅数据（支持多日查询）
+
+ RSS 数据与热榜新闻分开存储，按时间流展示，适合获取特定来源的最新内容。
+
+ Args:
+ feeds: RSS 源 ID 列表，如 ['hacker-news', '36kr']，不指定则返回所有源
+ days: 获取最近 N 天的数据，默认 1（仅今天），最大 30 天
+ limit: 返回条数限制，默认50，最大500
+ include_summary: 是否包含文章摘要，默认False（节省token）
+
+ Returns:
+ JSON格式的 RSS 条目列表
+
+ Examples:
+ - get_latest_rss()
+ - get_latest_rss(days=7, feeds=['hacker-news'])
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_latest_rss,
@@ -165,6 +292,26 @@ limit: int = 50,
include_summary: bool = False
) -> str:
+ """
+ 搜索 RSS 数据
+
+ 在 RSS 订阅数据中搜索包含指定关键词的文章。
+
+ Args:
+ keyword: 搜索关键词（必需）
+ feeds: RSS 源 ID 列表，如 ['hacker-news', '36kr']
+ - 不指定时：搜索所有 RSS 源
+ days: 搜索最近 N 天的数据，默认 7 天，最大 30 天
+ limit: 返回条数限制，默认50
+ include_summary: 是否包含文章摘要，默认False
+
+ Returns:
+ JSON格式的匹配 RSS 条目列表
+
+ Examples:
+ - search_rss(keyword="AI")
+ - search_rss(keyword="machine learning", feeds=['hacker-news'], days=14)
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].search_rss,
@@ -179,6 +326,22 @@
@mcp.tool
async def get_rss_feeds_status() -> str:
+ """
+ 获取 RSS 源状态信息
+
+ 查看当前配置的 RSS 源及其数据统计信息。
+
+ Returns:
+ JSON格式的 RSS 源状态，包含：
+ - available_dates: 有 RSS 数据的日期列表
+ - total_dates: 总日期数
+ - today_feeds: 今日各 RSS 源的数据统计
+ - {feed_id}: { name, item_count }
+ - generated_at: 生成时间
+
+ Examples:
+ - get_rss_feeds_status() # 查看所有 RSS 源状态
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['data'].get_rss_feeds_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -191,6 +354,22 @@ limit: int = 50,
include_url: bool = False
) -> str:
+ """
+ 获取指定日期的新闻数据，用于历史数据分析和对比
+
+ Args:
+ date_range: 日期范围，支持多种格式:
+ - 范围对象: {"start": "2025-01-01", "end": "2025-01-07"}
+ - 自然语言: "今天", "昨天", "本周", "最近7天"
+ - 单日字符串: "2025-01-15"
+ - 默认值: "今天"
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ limit: 返回条数限制，默认50，最大1000
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ JSON格式的新闻列表，包含标题、平台、排名等信息
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['data'].get_news_by_date,
@@ -216,6 +395,32 @@ lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> str:
+ """
+ 统一话题趋势分析工具 - 整合多种趋势分析模式
+
+ 建议：使用自然语言日期时，先调用 resolve_date_range 获取精确日期范围。
+
+ Args:
+ topic: 话题关键词（必需）
+ analysis_type: 分析类型
+ - "trend": 热度趋势分析（默认）
+ - "lifecycle": 生命周期分析
+ - "viral": 异常热度检测
+ - "predict": 话题预测
+ date_range: 日期范围，格式 {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}，默认最近7天
+ granularity: 时间粒度，默认"day"
+ spike_threshold: 热度突增倍数阈值（viral模式），默认3.0
+ time_window: 检测时间窗口小时数（viral模式），默认24
+ lookahead_hours: 预测未来小时数（predict模式），默认6
+ confidence_threshold: 置信度阈值（predict模式），默认0.7
+
+ Returns:
+ JSON格式的趋势分析结果
+
+ Examples:
+ - analyze_topic_trend(topic="AI", date_range={"start": "2025-01-01", "end": "2025-01-07"})
+ - analyze_topic_trend(topic="特斯拉", analysis_type="lifecycle")
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_topic_trend_unified,
@@ -239,6 +444,30 @@ min_frequency: int = 3,
top_n: int = 20
) -> str:
+ """
+ 统一数据洞察分析工具 - 整合多种数据分析模式
+
+ Args:
+ insight_type: 洞察类型，可选值：
+ - "platform_compare": 平台对比分析（对比不同平台对话题的关注度）
+ - "platform_activity": 平台活跃度统计（统计各平台发布频率和活跃时间）
+ - "keyword_cooccur": 关键词共现分析（分析关键词同时出现的模式）
+ topic: 话题关键词（可选，platform_compare模式适用）
+ date_range: **【对象类型】** 日期范围（可选）
+ - **格式**: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ - **示例**: {"start": "2025-01-01", "end": "2025-01-07"}
+ - **重要**: 必须是对象格式，不能传递整数
+ min_frequency: 最小共现频次（keyword_cooccur模式），默认3
+ top_n: 返回TOP N结果（keyword_cooccur模式），默认20
+
+ Returns:
+ JSON格式的数据洞察分析结果
+
+ Examples:
+ - analyze_data_insights(insight_type="platform_compare", topic="人工智能")
+ - analyze_data_insights(insight_type="platform_activity", date_range={"start": "2025-01-01", "end": "2025-01-07"})
+ - analyze_data_insights(insight_type="keyword_cooccur", min_frequency=5, top_n=15)
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_data_insights_unified,
@@ -260,6 +489,25 @@ sort_by_weight: bool = True,
include_url: bool = False
) -> str:
+ """
+ 分析新闻的情感倾向和热度趋势
+
+ 建议：使用自然语言日期时，先调用 resolve_date_range 获取精确日期范围。
+
+ Args:
+ topic: 话题关键词（可选）
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ date_range: 日期范围，格式 {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}，默认今天
+ limit: 返回新闻数量，默认50，最大100（会对标题去重）
+ sort_by_weight: 是否按热度权重排序，默认True
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ JSON格式的分析结果，包含情感分布、热度趋势和相关新闻
+
+ Examples:
+ - analyze_sentiment(topic="AI", date_range={"start": "2025-01-01", "end": "2025-01-07"})
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].analyze_sentiment,
@@ -281,6 +529,26 @@ limit: int = 50,
include_url: bool = False
) -> str:
+ """
+ 查找与指定新闻标题相关的其他新闻（支持当天和历史数据）
+
+ Args:
+ reference_title: 参考新闻标题（完整或部分）
+ date_range: 日期范围（可选）
+ - 不指定: 只查询今天的数据
+ - "today", "yesterday", "last_week", "last_month": 预设值
+ - {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}: 自定义范围
+ threshold: 相似度阈值，0-1之间，默认0.5（越高匹配越严格）
+ limit: 返回条数限制，默认50
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ JSON格式的相关新闻列表，按相似度排序
+
+ Examples:
+ - find_related_news(reference_title="特斯拉降价")
+ - find_related_news(reference_title="AI突破", date_range="last_week")
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['search'].find_related_news_unified,
@@ -298,6 +566,19 @@ report_type: str = "daily",
date_range: Optional[Union[Dict[str, str], str]] = None
) -> str:
+ """
+ 每日/每周摘要生成器 - 自动生成热点摘要报告
+
+ Args:
+ report_type: 报告类型（daily/weekly）
+ date_range: **【对象类型】** 自定义日期范围（可选）
+ - **格式**: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ - **示例**: {"start": "2025-01-01", "end": "2025-01-07"}
+ - **重要**: 必须是对象格式，不能传递整数
+
+ Returns:
+ JSON格式的摘要报告，包含Markdown格式内容
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].generate_summary_report,
@@ -315,6 +596,25 @@ limit: int = 50,
include_url: bool = False
) -> str:
+ """
+ 跨平台新闻聚合 - 对相似新闻进行去重合并
+
+ 将不同平台报道的同一事件合并为一条聚合新闻，显示跨平台覆盖情况和综合热度。
+
+ Args:
+ date_range: 日期范围，不指定则查询今天
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ similarity_threshold: 相似度阈值，0.3-1.0，默认0.7（越高越严格）
+ limit: 返回聚合新闻数量，默认50
+ include_url: 是否包含URL链接，默认False
+
+ Returns:
+ JSON格式的聚合结果，包含去重统计、聚合新闻列表和平台覆盖统计
+
+ Examples:
+ - aggregate_news()
+ - aggregate_news(similarity_threshold=0.8)
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].aggregate_news,
@@ -336,6 +636,44 @@ platforms: Optional[List[str]] = None,
top_n: int = 10
) -> str:
+ """
+ 时期对比分析 - 比较两个时间段的新闻数据
+
+ 对比不同时期的热点话题、平台活跃度、新闻数量等维度。
+
+ **使用场景：**
+ - 对比本周和上周的热点变化
+ - 分析某个话题在两个时期的热度差异
+ - 查看各平台活跃度的周期性变化
+
+ Args:
+ period1: 第一个时间段（基准期）
+ - {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}: 日期范围
+ - "today", "yesterday", "this_week", "last_week", "this_month", "last_month": 预设值
+ period2: 第二个时间段（对比期，格式同 period1）
+ topic: 可选的话题关键词（聚焦特定话题的对比）
+ compare_type: 对比类型
+ - "overview": 总体概览（默认）- 新闻数量、关键词变化、TOP新闻
+ - "topic_shift": 话题变化分析 - 上升话题、下降话题、新出现话题
+ - "platform_activity": 平台活跃度对比 - 各平台新闻数量变化
+ platforms: 平台过滤列表，如 ['zhihu', 'weibo']
+ top_n: 返回 TOP N 结果，默认10
+
+ Returns:
+ JSON格式的对比分析结果，包含：
+ - periods: 两个时期的日期范围
+ - compare_type: 对比类型
+ - overview/topic_shift/platform_comparison: 具体对比结果（根据类型）
+
+ Examples:
+ - compare_periods(period1="last_week", period2="this_week") # 周环比
+ - compare_periods(period1="last_month", period2="this_month", compare_type="topic_shift")
+ - compare_periods(
+ period1={"start": "2025-01-01", "end": "2025-01-07"},
+ period2={"start": "2025-01-08", "end": "2025-01-14"},
+ topic="人工智能"
+ )
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['analytics'].compare_periods,
@@ -364,6 +702,34 @@ include_rss: bool = False,
rss_limit: int = 20
) -> str:
+ """
+ 统一搜索接口，支持多种搜索模式，可同时搜索热榜和RSS
+
+ 建议：使用自然语言日期时，先调用 resolve_date_range 获取精确日期范围。
+
+ Args:
+ query: 搜索关键词或内容片段
+ search_mode: 搜索模式
+ - "keyword": 精确关键词匹配（默认）
+ - "fuzzy": 模糊内容匹配
+ - "entity": 实体名称搜索（人物/地点/机构）
+ date_range: 日期范围，格式 {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}，默认今天
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ limit: 热榜返回条数限制，默认50
+ sort_by: 排序方式 - "relevance"（相关度）/ "weight"（权重）/ "date"（日期）
+ threshold: 相似度阈值（仅fuzzy模式），0-1，默认0.6
+ include_url: 是否包含URL链接，默认False
+ include_rss: 是否同时搜索RSS数据，默认False
+ rss_limit: RSS返回条数限制，默认20
+
+ Returns:
+ JSON格式的搜索结果，包含热榜新闻列表和可选的RSS结果
+
+ Examples:
+ - search_news(query="AI")
+ - search_news(query="AI", include_rss=True)
+ - search_news(query="特斯拉", date_range={"start": "2025-01-01", "end": "2025-01-07"})
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['search'].search_news_unified,
@@ -387,6 +753,20 @@ async def get_current_config(
section: str = "all"
) -> str:
+ """
+ 获取当前系统配置
+
+ Args:
+ section: 配置节，可选值：
+ - "all": 所有配置（默认）
+ - "crawler": 爬虫配置
+ - "push": 推送配置
+ - "keywords": 关键词配置
+ - "weights": 权重配置
+
+ Returns:
+ JSON格式的配置信息
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['config'].get_current_config, section=section)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -394,6 +774,14 @@
@mcp.tool
async def get_system_status() -> str:
+ """
+ 获取系统运行状态和健康检查信息
+
+ 返回系统版本、数据统计、缓存状态等信息
+
+ Returns:
+ JSON格式的系统状态信息
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['system'].get_system_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -403,6 +791,21 @@ async def check_version(
proxy_url: Optional[str] = None
) -> str:
+ """
+ 检查版本更新（同时检查 TrendRadar 和 MCP Server）
+
+ 比较本地版本与 GitHub 远程版本，判断是否需要更新。
+
+ Args:
+ proxy_url: 可选的代理URL，用于访问 GitHub（如 http://127.0.0.1:7890）
+
+ Returns:
+ JSON格式的版本检查结果，包含两个组件的版本对比和是否需要更新
+
+ Examples:
+ - check_version()
+ - check_version(proxy_url="http://127.0.0.1:7890")
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['system'].check_version, proxy_url=proxy_url)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -414,6 +817,21 @@ save_to_local: bool = False,
include_url: bool = False
) -> str:
+ """
+ 手动触发一次爬取任务（可选持久化）
+
+ Args:
+ platforms: 平台ID列表，如 ['zhihu', 'weibo']，不指定则使用所有平台
+ save_to_local: 是否保存到本地 output 目录，默认 False
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ JSON格式的任务状态信息，包含成功/失败平台列表和新闻数据
+
+ Examples:
+ - trigger_crawl(platforms=['zhihu'])
+ - trigger_crawl(save_to_local=True)
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['system'].trigger_crawl,
@@ -428,6 +846,38 @@ async def sync_from_remote(
days: int = 7
) -> str:
+ """
+ 从远程存储拉取数据到本地
+
+ 用于 MCP Server 等场景：爬虫存到远程云存储（如 Cloudflare R2），
+ MCP Server 拉取到本地进行分析查询。
+
+ Args:
+ days: 拉取最近 N 天的数据，默认 7 天
+ - 0: 不拉取
+ - 7: 拉取最近一周的数据
+ - 30: 拉取最近一个月的数据
+
+ Returns:
+ JSON格式的同步结果，包含：
+ - success: 是否成功
+ - synced_files: 成功同步的文件数量
+ - synced_dates: 成功同步的日期列表
+ - skipped_dates: 跳过的日期（本地已存在）
+ - failed_dates: 失败的日期及错误信息
+ - message: 操作结果描述
+
+ Examples:
+ - sync_from_remote() # 拉取最近7天
+ - sync_from_remote(days=30) # 拉取最近30天
+
+ Note:
+ 需要在 config/config.yaml 中配置远程存储（storage.remote）或设置环境变量：
+ - S3_ENDPOINT_URL: 服务端点
+ - S3_BUCKET_NAME: 存储桶名称
+ - S3_ACCESS_KEY_ID: 访问密钥 ID
+ - S3_SECRET_ACCESS_KEY: 访问密钥
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].sync_from_remote, days=days)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -435,6 +885,14 @@
@mcp.tool
async def get_storage_status() -> str:
+ """
+ 获取存储配置和状态
+
+ 查看当前存储后端配置、本地和远程存储的状态信息。
+
+ Returns:
+ JSON格式的存储状态信息，包含本地/远程存储状态和拉取配置
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].get_storage_status)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -444,6 +902,24 @@ async def list_available_dates(
source: str = "both"
) -> str:
+ """
+ 列出本地/远程可用的日期范围
+
+ 查看本地和远程存储中有哪些日期的数据可用。
+
+ Args:
+ source: 数据来源
+ - "local": 仅本地
+ - "remote": 仅远程
+ - "both": 同时列出并对比（默认）
+
+ Returns:
+ JSON格式的日期列表，包含各来源的日期信息和对比结果
+
+ Examples:
+ - list_available_dates()
+ - list_available_dates(source="local")
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['storage'].list_available_dates, source=source)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -456,6 +932,32 @@ url: str,
timeout: int = 30
) -> str:
+ """
+ 读取指定 URL 的文章内容，返回 LLM 友好的 Markdown 格式
+
+ 通过 Jina AI Reader 将网页转换为干净的 Markdown，自动去除广告、导航栏等噪音内容。
+ 适合用于：阅读新闻正文、获取文章详情、分析文章内容。
+
+ **典型使用流程：**
+ 1. 先用 search_news(include_url=True) 搜索新闻获取链接
+ 2. 再用 read_article(url=链接) 读取正文内容
+ 3. AI 对 Markdown 正文进行分析、摘要、翻译等
+
+ Args:
+ url: 文章链接（必需），以 http:// 或 https:// 开头
+ timeout: 请求超时时间（秒），默认 30，最大 60
+
+ Returns:
+ JSON格式的文章内容，包含完整 Markdown 正文
+
+ Examples:
+ - read_article(url="https://example.com/news/123")
+
+ Note:
+ - 使用 Jina AI Reader 免费服务（100 RPM 限制）
+ - 每次请求间隔 5 秒（内置速率控制）
+ - 部分付费墙/登录墙页面可能无法完整获取
+ """
tools = _get_tools()
timeout = min(max(timeout, 10), 60)
result = await asyncio.to_thread(
@@ -470,6 +972,31 @@ urls: List[str],
timeout: int = 30
) -> str:
+ """
+ 批量读取多篇文章内容（最多 5 篇，间隔 5 秒）
+
+ 逐篇请求文章内容，每篇之间自动间隔 5 秒以遵守速率限制。
+
+ **典型使用流程：**
+ 1. 先用 search_news(include_url=True) 搜索新闻获取多个链接
+ 2. 再用 read_articles_batch(urls=[...]) 批量读取正文
+ 3. AI 对多篇文章进行对比分析、综合报告
+
+ Args:
+ urls: 文章链接列表（必需），最多处理 5 篇
+ timeout: 每篇的请求超时时间（秒），默认 30
+
+ Returns:
+ JSON格式的批量读取结果，包含每篇的完整内容和状态
+
+ Examples:
+ - read_articles_batch(urls=["https://a.com/1", "https://b.com/2"])
+
+ Note:
+ - 单次最多读取 5 篇，超出部分会被跳过
+ - 5 篇约需 25-30 秒（每篇间隔 5 秒）
+ - 单篇失败不影响其他篇的读取
+ """
tools = _get_tools()
timeout = min(max(timeout, 10), 60)
result = await asyncio.to_thread(
@@ -484,6 +1011,36 @@
@mcp.tool
async def get_channel_format_guide(channel: Optional[str] = None) -> str:
+ """
+ 获取通知渠道的格式化策略指南
+
+ 返回各渠道支持的 Markdown 特性、格式限制和最佳格式化提示词。
+ 在调用 send_notification 之前使用此工具，可以了解目标渠道的格式要求，
+ 从而生成最佳排版效果的消息内容。
+
+ 各渠道格式差异概览：
+ - 飞书：支持 **粗体**、<font color>彩色文本、[链接](url)、--- 分割线
+ - 钉钉：支持 ### 标题、**粗体**、> 引用、--- 分割线，不支持颜色
+ - 企业微信：仅支持 **粗体**、[链接](url)、> 引用，不支持标题和分割线
+ - Telegram：自动转为 HTML，支持粗体/斜体/删除线/代码/链接/引用块
+ - ntfy：支持标准 Markdown，不支持颜色
+ - Bark：iOS 推送，仅支持粗体和链接，内容需精简
+ - Slack：自动转为 mrkdwn，*粗体*、~删除线~、<url|链接>
+ - 邮件：自动转为完整 HTML 网页，支持标题/样式/分割线
+ - 通用 Webhook：标准 Markdown 或自定义模板
+
+ Args:
+ channel: 指定渠道 ID（可选），不指定返回所有渠道策略
+ 可选值: feishu, dingtalk, wework, telegram, email, ntfy, bark, slack, generic_webhook
+
+ Returns:
+ JSON格式的渠道格式化策略，包含支持特性、限制和格式化提示词
+
+ Examples:
+ - get_channel_format_guide() # 获取所有渠道策略
+ - get_channel_format_guide(channel="feishu") # 获取飞书策略
+ - get_channel_format_guide(channel="telegram") # 获取 Telegram 策略
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['notification'].get_channel_format_guide,
@@ -494,6 +1051,18 @@
@mcp.tool
async def get_notification_channels() -> str:
+ """
+ 获取所有已配置的通知渠道及其状态
+
+ 检测 config.yaml 和 .env 环境变量中的通知渠道配置。
+ 支持 9 个渠道：飞书、钉钉、企业微信、Telegram、邮件、ntfy、Bark、Slack、通用 Webhook。
+
+ Returns:
+ JSON格式的渠道状态，包含每个渠道是否已配置及配置来源
+
+ Examples:
+ - get_notification_channels()
+ """
tools = _get_tools()
result = await asyncio.to_thread(tools['notification'].get_notification_channels)
return json.dumps(result, ensure_ascii=False, indent=2)
@@ -505,6 +1074,36 @@ title: str = "TrendRadar 通知",
channels: Optional[List[str]] = None,
) -> str:
+ """
+ 向已配置的通知渠道发送消息
+
+ 接受 markdown 格式内容，内部自动适配各渠道的格式要求和限制：
+ - 飞书：Markdown 卡片消息（支持 **粗体**、<font color>彩色文本、[链接](url)、---）
+ - 钉钉：Markdown（自动降级标题为 ###、剥离 <font> 标签和删除线）
+ - 企业微信：Markdown（自动剥离 # 标题、---、<font> 标签、删除线）
+ - Telegram：HTML（自动转换 **→<b>、*→<i>、~~→<s>、>→<blockquote>）
+ - Email：HTML 邮件（完整网页样式，支持 # 标题、---、粗体斜体）
+ - ntfy：Markdown（自动剥离 <font> 标签）
+ - Bark：Markdown（自动简化为粗体+链接，适配 iOS 推送）
+ - Slack：mrkdwn（自动转换 **→*、~~→~、[text](url)→<url|text>）
+ - 通用 Webhook：Markdown（支持自定义模板）
+
+ 提示：发送前可调用 get_channel_format_guide 获取目标渠道的详细格式化策略，
+ 以生成最佳排版效果的消息内容。
+
+ Args:
+ message: markdown 格式的消息内容（必需）
+ title: 消息标题，默认 "TrendRadar 通知"
+ channels: 指定发送的渠道列表，不指定则发送到所有已配置渠道
+ 可选值: feishu, dingtalk, wework, telegram, email, ntfy, bark, slack, generic_webhook
+
+ Returns:
+ JSON格式的发送结果，包含每个渠道的发送状态
+
+ Examples:
+ - send_notification(message="**测试消息**\\n这是一条测试通知")
+ - send_notification(message="紧急通知", title="系统告警", channels=["feishu", "dingtalk"])
+ """
tools = _get_tools()
result = await asyncio.to_thread(
tools['notification'].send_notification,
@@ -521,6 +1120,15 @@ host: str = '0.0.0.0',
port: int = 3333
):
+ """
+ 启动 MCP 服务器
+
+ Args:
+ project_root: 项目根目录路径
+ transport: 传输模式，'stdio' 或 'http'
+ host: HTTP模式的监听地址，默认 0.0.0.0
+ port: HTTP模式的监听端口，默认 3333
+ """
# 初始化工具实例
_get_tools(project_root)
@@ -646,4 +1254,4 @@ transport=args.transport,
host=args.host,
port=args.port
- )+ )
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/server.py |
Annotate my code with docstrings |
import os
import re
from collections import Counter, defaultdict
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Union
from difflib import SequenceMatcher
import yaml
from trendradar.core.analyzer import calculate_news_weight as _calculate_news_weight
from ..services.data_service import DataService
from ..utils.validators import (
validate_platforms,
validate_limit,
validate_keyword,
validate_top_n,
validate_date_range,
validate_threshold
)
from ..utils.errors import MCPError, InvalidParameterError, DataNotFoundError
# 权重配置 mtime 缓存（避免重复读取同一配置文件）
_weight_config_cache: Optional[Dict] = None
_weight_config_mtime: float = 0.0
_weight_config_path: Optional[str] = None
_WEIGHT_DEFAULT_CONFIG = {
"RANK_WEIGHT": 0.6,
"FREQUENCY_WEIGHT": 0.3,
"HOTNESS_WEIGHT": 0.1,
}
def _get_weight_config() -> Dict:
global _weight_config_cache, _weight_config_mtime, _weight_config_path
try:
# 首次调用时计算路径（之后复用）
if _weight_config_path is None:
current_dir = os.path.dirname(os.path.abspath(__file__))
_weight_config_path = os.path.normpath(
os.path.join(current_dir, "..", "..", "config", "config.yaml")
)
current_mtime = os.path.getmtime(_weight_config_path)
# 文件未修改且缓存有效，直接返回
if _weight_config_cache is not None and current_mtime == _weight_config_mtime:
return _weight_config_cache
# 文件已修改或首次读取，重新解析
with open(_weight_config_path, 'r', encoding='utf-8') as f:
config = yaml.safe_load(f)
weight = config.get('advanced', {}).get('weight', {})
_weight_config_cache = {
"RANK_WEIGHT": weight.get('rank', 0.6),
"FREQUENCY_WEIGHT": weight.get('frequency', 0.3),
"HOTNESS_WEIGHT": weight.get('hotness', 0.1),
}
_weight_config_mtime = current_mtime
return _weight_config_cache
except Exception:
return _WEIGHT_DEFAULT_CONFIG
def calculate_news_weight(news_data: Dict, rank_threshold: int = 5) -> float:
return _calculate_news_weight(news_data, rank_threshold, _get_weight_config())
class AnalyticsTools:
def __init__(self, project_root: str = None):
self.data_service = DataService(project_root)
def analyze_data_insights_unified(
self,
insight_type: str = "platform_compare",
topic: Optional[str] = None,
date_range: Optional[Union[Dict[str, str], str]] = None,
min_frequency: int = 3,
top_n: int = 20
) -> Dict:
try:
# 参数验证
if insight_type not in ["platform_compare", "platform_activity", "keyword_cooccur"]:
raise InvalidParameterError(
f"无效的洞察类型: {insight_type}",
suggestion="支持的类型: platform_compare, platform_activity, keyword_cooccur"
)
# 根据洞察类型调用相应方法
if insight_type == "platform_compare":
return self.compare_platforms(
topic=topic,
date_range=date_range
)
elif insight_type == "platform_activity":
return self.get_platform_activity_stats(
date_range=date_range
)
else: # keyword_cooccur
return self.analyze_keyword_cooccurrence(
min_frequency=min_frequency,
top_n=top_n
)
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def analyze_topic_trend_unified(
self,
topic: str,
analysis_type: str = "trend",
date_range: Optional[Union[Dict[str, str], str]] = None,
granularity: str = "day",
threshold: float = 3.0,
time_window: int = 24,
lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> Dict:
try:
# 参数验证
topic = validate_keyword(topic)
if analysis_type not in ["trend", "lifecycle", "viral", "predict"]:
raise InvalidParameterError(
f"无效的分析类型: {analysis_type}",
suggestion="支持的类型: trend, lifecycle, viral, predict"
)
# 根据分析类型调用相应方法
if analysis_type == "trend":
return self.get_topic_trend_analysis(
topic=topic,
date_range=date_range,
granularity=granularity
)
elif analysis_type == "lifecycle":
return self.analyze_topic_lifecycle(
topic=topic,
date_range=date_range
)
elif analysis_type == "viral":
# viral模式不需要topic参数，使用通用检测
return self.detect_viral_topics(
threshold=threshold,
time_window=time_window
)
else: # predict
# predict模式不需要topic参数，使用通用预测
return self.predict_trending_topics(
lookahead_hours=lookahead_hours,
confidence_threshold=confidence_threshold
)
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def get_topic_trend_analysis(
self,
topic: str,
date_range: Optional[Union[Dict[str, str], str]] = None,
granularity: str = "day"
) -> Dict:
try:
# 验证参数
topic = validate_keyword(topic)
# 验证粒度参数（只支持day）
if granularity != "day":
from ..utils.errors import InvalidParameterError
raise InvalidParameterError(
f"不支持的粒度参数: {granularity}",
suggestion="当前仅支持 'day' 粒度，因为底层数据按天聚合"
)
# 处理日期范围（不指定时默认最近7天）
if date_range:
from ..utils.validators import validate_date_range
date_range_tuple = validate_date_range(date_range)
start_date, end_date = date_range_tuple
else:
# 默认最近7天
end_date = datetime.now()
start_date = end_date - timedelta(days=6)
# 收集趋势数据
trend_data = []
current_date = start_date
while current_date <= end_date:
try:
all_titles, _, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date
)
# 统计该时间点的话题出现次数
count = 0
matched_titles = []
for _, titles in all_titles.items():
for title in titles.keys():
if topic.lower() in title.lower():
count += 1
matched_titles.append(title)
trend_data.append({
"date": current_date.strftime("%Y-%m-%d"),
"count": count,
"sample_titles": matched_titles[:3] # 只保留前3个样本
})
except DataNotFoundError:
trend_data.append({
"date": current_date.strftime("%Y-%m-%d"),
"count": 0,
"sample_titles": []
})
# 按天增加时间
current_date += timedelta(days=1)
# 计算趋势指标
counts = [item["count"] for item in trend_data]
total_days = (end_date - start_date).days + 1
if len(counts) >= 2:
# 计算涨跌幅度
first_non_zero = next((c for c in counts if c > 0), 0)
last_count = counts[-1]
if first_non_zero > 0:
change_rate = ((last_count - first_non_zero) / first_non_zero) * 100
else:
change_rate = 0
# 找到峰值时间
max_count = max(counts)
peak_index = counts.index(max_count)
peak_time = trend_data[peak_index]["date"]
else:
change_rate = 0
peak_time = None
max_count = 0
return {
"success": True,
"summary": {
"description": f"话题「{topic}」的热度趋势分析",
"topic": topic,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d"),
"total_days": total_days
},
"granularity": granularity,
"total_mentions": sum(counts),
"average_mentions": round(sum(counts) / len(counts), 2) if counts else 0,
"peak_count": max_count,
"peak_time": peak_time,
"change_rate": round(change_rate, 2),
"trend_direction": "上升" if change_rate > 10 else "下降" if change_rate < -10 else "稳定"
},
"data": trend_data
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def compare_platforms(
self,
topic: Optional[str] = None,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
try:
# 参数验证
if topic:
topic = validate_keyword(topic)
date_range_tuple = validate_date_range(date_range)
# 确定日期范围
if date_range_tuple:
start_date, end_date = date_range_tuple
else:
start_date = end_date = datetime.now()
# 收集各平台数据
platform_stats = defaultdict(lambda: {
"total_news": 0,
"topic_mentions": 0,
"unique_titles": set(),
"top_keywords": Counter()
})
# 遍历日期范围
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date
)
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title in titles.keys():
platform_stats[platform_name]["total_news"] += 1
platform_stats[platform_name]["unique_titles"].add(title)
# 如果指定了话题，统计包含话题的新闻
if topic and topic.lower() in title.lower():
platform_stats[platform_name]["topic_mentions"] += 1
# 提取关键词（简单分词）
keywords = self._extract_keywords(title)
platform_stats[platform_name]["top_keywords"].update(keywords)
except DataNotFoundError:
pass
current_date += timedelta(days=1)
# 转换为可序列化的格式
result_stats = {}
for platform, stats in platform_stats.items():
coverage_rate = 0
if stats["total_news"] > 0:
coverage_rate = (stats["topic_mentions"] / stats["total_news"]) * 100
result_stats[platform] = {
"total_news": stats["total_news"],
"topic_mentions": stats["topic_mentions"],
"unique_titles": len(stats["unique_titles"]),
"coverage_rate": round(coverage_rate, 2),
"top_keywords": [
{"keyword": k, "count": v}
for k, v in stats["top_keywords"].most_common(5)
]
}
# 找出各平台独有的热点
unique_topics = self._find_unique_topics(platform_stats)
return {
"success": True,
"topic": topic,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d")
},
"platform_stats": result_stats,
"unique_topics": unique_topics,
"total_platforms": len(result_stats)
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def analyze_keyword_cooccurrence(
self,
min_frequency: int = 3,
top_n: int = 20
) -> Dict:
try:
# 参数验证
min_frequency = validate_limit(min_frequency, default=3, max_limit=100)
top_n = validate_top_n(top_n, default=20)
# 读取今天的数据
all_titles, _, _ = self.data_service.parser.read_all_titles_for_date()
# 关键词共现统计
cooccurrence = Counter()
keyword_titles = defaultdict(list)
for platform_id, titles in all_titles.items():
for title in titles.keys():
# 提取关键词
keywords = self._extract_keywords(title)
# 记录每个关键词出现的标题
for kw in keywords:
keyword_titles[kw].append(title)
# 计算两两共现
if len(keywords) >= 2:
for i, kw1 in enumerate(keywords):
for kw2 in keywords[i+1:]:
# 统一排序，避免重复
pair = tuple(sorted([kw1, kw2]))
cooccurrence[pair] += 1
# 过滤低频共现
filtered_pairs = [
(pair, count) for pair, count in cooccurrence.items()
if count >= min_frequency
]
# 排序并取TOP N
top_pairs = sorted(filtered_pairs, key=lambda x: x[1], reverse=True)[:top_n]
# 构建结果
result_pairs = []
for (kw1, kw2), count in top_pairs:
# 找出同时包含两个关键词的标题样本
titles_with_both = [
title for title in keyword_titles[kw1]
if kw2 in self._extract_keywords(title)
]
result_pairs.append({
"keyword1": kw1,
"keyword2": kw2,
"cooccurrence_count": count,
"sample_titles": titles_with_both[:3]
})
return {
"success": True,
"summary": {
"description": "关键词共现分析结果",
"total": len(result_pairs),
"min_frequency": min_frequency,
"generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
},
"data": result_pairs
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def analyze_sentiment(
self,
topic: Optional[str] = None,
platforms: Optional[List[str]] = None,
date_range: Optional[Union[Dict[str, str], str]] = None,
limit: int = 50,
sort_by_weight: bool = True,
include_url: bool = False
) -> Dict:
try:
# 参数验证
if topic:
topic = validate_keyword(topic)
platforms = validate_platforms(platforms)
limit = validate_limit(limit, default=50)
# 处理日期范围
if date_range:
date_range_tuple = validate_date_range(date_range)
start_date, end_date = date_range_tuple
else:
# 默认今天
start_date = end_date = datetime.now()
# 收集新闻数据（支持多天）
all_news_items = []
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date,
platform_ids=platforms
)
# 收集该日期的新闻
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
# 如果指定了话题，只收集包含话题的标题
if topic and topic.lower() not in title.lower():
continue
news_item = {
"platform": platform_name,
"title": title,
"ranks": info.get("ranks", []),
"count": len(info.get("ranks", [])),
"date": current_date.strftime("%Y-%m-%d")
}
# 条件性添加 URL 字段
if include_url:
news_item["url"] = info.get("url", "")
news_item["mobileUrl"] = info.get("mobileUrl", "")
all_news_items.append(news_item)
except DataNotFoundError:
# 该日期没有数据，继续下一天
pass
# 下一天
current_date += timedelta(days=1)
if not all_news_items:
time_desc = "今天" if start_date == end_date else f"{start_date.strftime('%Y-%m-%d')} 至 {end_date.strftime('%Y-%m-%d')}"
raise DataNotFoundError(
f"未找到相关新闻（{time_desc}）",
suggestion="请尝试其他话题、日期范围或平台"
)
# 去重（同一标题只保留一次）
unique_news = {}
for item in all_news_items:
key = f"{item['platform']}::{item['title']}"
if key not in unique_news:
unique_news[key] = item
else:
# 合并 ranks（如果同一新闻在多天出现）
existing = unique_news[key]
existing["ranks"].extend(item["ranks"])
existing["count"] = len(existing["ranks"])
deduplicated_news = list(unique_news.values())
# 按权重排序（如果启用）
if sort_by_weight:
deduplicated_news.sort(
key=lambda x: calculate_news_weight(x),
reverse=True
)
# 限制返回数量
selected_news = deduplicated_news[:limit]
# 生成 AI 提示词
ai_prompt = self._create_sentiment_analysis_prompt(
news_data=selected_news,
topic=topic
)
# 构建时间范围描述
if start_date == end_date:
time_range_desc = start_date.strftime("%Y-%m-%d")
else:
time_range_desc = f"{start_date.strftime('%Y-%m-%d')} 至 {end_date.strftime('%Y-%m-%d')}"
result = {
"success": True,
"method": "ai_prompt_generation",
"summary": {
"description": "情感分析数据和AI提示词",
"total_found": len(deduplicated_news),
"returned": len(selected_news),
"requested_limit": limit,
"duplicates_removed": len(all_news_items) - len(deduplicated_news),
"topic": topic,
"time_range": time_range_desc,
"platforms": list(set(item["platform"] for item in selected_news)),
"sorted_by_weight": sort_by_weight
},
"ai_prompt": ai_prompt,
"data": selected_news,
"usage_note": "请将 ai_prompt 字段的内容发送给 AI 进行情感分析"
}
# 如果返回数量少于请求数量，增加提示
if len(selected_news) < limit and len(deduplicated_news) >= limit:
result["note"] = "返回数量少于请求数量是因为去重逻辑（同一标题在不同平台只保留一次）"
elif len(deduplicated_news) < limit:
result["note"] = f"在指定时间范围内仅找到 {len(deduplicated_news)} 条匹配的新闻"
return result
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def _create_sentiment_analysis_prompt(
self,
news_data: List[Dict],
topic: Optional[str]
) -> str:
# 按平台分组
platform_news = defaultdict(list)
for item in news_data:
platform_news[item["platform"]].append({
"title": item["title"],
"date": item.get("date", "")
})
# 构建提示词
prompt_parts = []
# 1. 任务说明
if topic:
prompt_parts.append(f"请分析以下关于「{topic}」的新闻标题的情感倾向。")
else:
prompt_parts.append("请分析以下新闻标题的情感倾向。")
prompt_parts.append("")
prompt_parts.append("分析要求：")
prompt_parts.append("1. 识别每条新闻的情感倾向（正面/负面/中性）")
prompt_parts.append("2. 统计各情感类别的数量和百分比")
prompt_parts.append("3. 分析不同平台的情感差异")
prompt_parts.append("4. 总结整体情感趋势")
prompt_parts.append("5. 列举典型的正面和负面新闻样本")
prompt_parts.append("")
# 2. 数据概览
prompt_parts.append(f"数据概览：")
prompt_parts.append(f"- 总新闻数：{len(news_data)}")
prompt_parts.append(f"- 覆盖平台：{len(platform_news)}")
# 时间范围
dates = set(item.get("date", "") for item in news_data if item.get("date"))
if dates:
date_list = sorted(dates)
if len(date_list) == 1:
prompt_parts.append(f"- 时间范围：{date_list[0]}")
else:
prompt_parts.append(f"- 时间范围：{date_list[0]} 至 {date_list[-1]}")
prompt_parts.append("")
# 3. 按平台展示新闻
prompt_parts.append("新闻列表（按平台分类，已按重要性排序）：")
prompt_parts.append("")
for platform, items in sorted(platform_news.items()):
prompt_parts.append(f"【{platform}】({len(items)} 条)")
for i, item in enumerate(items, 1):
title = item["title"]
date_str = f" [{item['date']}]" if item.get("date") else ""
prompt_parts.append(f"{i}. {title}{date_str}")
prompt_parts.append("")
# 4. 输出格式说明
prompt_parts.append("请按以下格式输出分析结果：")
prompt_parts.append("")
prompt_parts.append("## 情感分布统计")
prompt_parts.append("- 正面：XX条 (XX%)")
prompt_parts.append("- 负面：XX条 (XX%)")
prompt_parts.append("- 中性：XX条 (XX%)")
prompt_parts.append("")
prompt_parts.append("## 平台情感对比")
prompt_parts.append("[各平台的情感倾向差异]")
prompt_parts.append("")
prompt_parts.append("## 整体情感趋势")
prompt_parts.append("[总体分析和关键发现]")
prompt_parts.append("")
prompt_parts.append("## 典型样本")
prompt_parts.append("正面新闻样本：")
prompt_parts.append("[列举3-5条]")
prompt_parts.append("")
prompt_parts.append("负面新闻样本：")
prompt_parts.append("[列举3-5条]")
return "\n".join(prompt_parts)
def find_similar_news(
self,
reference_title: str,
threshold: float = 0.6,
limit: int = 50,
include_url: bool = False
) -> Dict:
try:
# 参数验证
reference_title = validate_keyword(reference_title)
threshold = validate_threshold(threshold, default=0.6, min_value=0.0, max_value=1.0)
limit = validate_limit(limit, default=50)
# 读取数据
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date()
# 计算相似度
similar_items = []
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
if title == reference_title:
continue
# 计算相似度
similarity = self._calculate_similarity(reference_title, title)
if similarity >= threshold:
news_item = {
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"similarity": round(similarity, 3),
"rank": info["ranks"][0] if info["ranks"] else 0
}
# 条件性添加 URL 字段
if include_url:
news_item["url"] = info.get("url", "")
similar_items.append(news_item)
# 按相似度排序
similar_items.sort(key=lambda x: x["similarity"], reverse=True)
# 限制数量
result_items = similar_items[:limit]
if not result_items:
raise DataNotFoundError(
f"未找到相似度超过 {threshold} 的新闻",
suggestion="请降低相似度阈值或尝试其他标题"
)
result = {
"success": True,
"summary": {
"description": "相似新闻搜索结果",
"total_found": len(similar_items),
"returned": len(result_items),
"requested_limit": limit,
"threshold": threshold,
"reference_title": reference_title
},
"data": result_items
}
if len(similar_items) < limit:
result["note"] = f"相似度阈值 {threshold} 下仅找到 {len(similar_items)} 条相似新闻"
return result
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def search_by_entity(
self,
entity: str,
entity_type: Optional[str] = None,
limit: int = 50,
sort_by_weight: bool = True
) -> Dict:
try:
# 参数验证
entity = validate_keyword(entity)
limit = validate_limit(limit, default=50)
if entity_type and entity_type not in ["person", "location", "organization"]:
raise InvalidParameterError(
f"无效的实体类型: {entity_type}",
suggestion="支持的类型: person, location, organization"
)
# 读取数据
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date()
# 搜索包含实体的新闻
related_news = []
entity_context = Counter() # 统计实体周边的词
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
if entity in title:
url = info.get("url", "")
mobile_url = info.get("mobileUrl", "")
ranks = info.get("ranks", [])
count = len(ranks)
related_news.append({
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"url": url,
"mobileUrl": mobile_url,
"ranks": ranks,
"count": count,
"rank": ranks[0] if ranks else 999
})
# 提取实体周边的关键词
keywords = self._extract_keywords(title)
entity_context.update(keywords)
if not related_news:
raise DataNotFoundError(
f"未找到包含实体 '{entity}' 的新闻",
suggestion="请尝试其他实体名称"
)
# 移除实体本身
if entity in entity_context:
del entity_context[entity]
# 按权重排序（如果启用）
if sort_by_weight:
related_news.sort(
key=lambda x: calculate_news_weight(x),
reverse=True
)
else:
# 按排名排序
related_news.sort(key=lambda x: x["rank"])
# 限制返回数量
result_news = related_news[:limit]
return {
"success": True,
"summary": {
"description": f"实体「{entity}」相关新闻",
"entity": entity,
"entity_type": entity_type or "auto",
"total_found": len(related_news),
"returned": len(result_news),
"sorted_by_weight": sort_by_weight
},
"data": result_news,
"related_keywords": [
{"keyword": k, "count": v}
for k, v in entity_context.most_common(10)
]
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def generate_summary_report(
self,
report_type: str = "daily",
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
try:
# 参数验证
if report_type not in ["daily", "weekly"]:
raise InvalidParameterError(
f"无效的报告类型: {report_type}",
suggestion="支持的类型: daily, weekly"
)
# 确定日期范围
if date_range:
date_range_tuple = validate_date_range(date_range)
start_date, end_date = date_range_tuple
else:
if report_type == "daily":
start_date = end_date = datetime.now()
else: # weekly
end_date = datetime.now()
start_date = end_date - timedelta(days=6)
# 收集数据
all_keywords = Counter()
all_platforms_news = defaultdict(int)
all_titles_list = []
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date
)
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
all_platforms_news[platform_name] += len(titles)
for title in titles.keys():
all_titles_list.append({
"title": title,
"platform": platform_name,
"date": current_date.strftime("%Y-%m-%d")
})
# 提取关键词
keywords = self._extract_keywords(title)
all_keywords.update(keywords)
except DataNotFoundError:
pass
current_date += timedelta(days=1)
# 生成报告
report_title = f"{'每日' if report_type == 'daily' else '每周'}新闻热点摘要"
date_str = f"{start_date.strftime('%Y-%m-%d')}" if report_type == "daily" else f"{start_date.strftime('%Y-%m-%d')} 至 {end_date.strftime('%Y-%m-%d')}"
# 构建Markdown报告
markdown = f"""# {report_title}
**报告日期**: {date_str}
**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
---
## 📊 数据概览
- **总新闻数**: {len(all_titles_list)}
- **覆盖平台**: {len(all_platforms_news)}
- **热门关键词数**: {len(all_keywords)}
## 🔥 TOP 10 热门话题
"""
# 添加TOP 10关键词
for i, (keyword, count) in enumerate(all_keywords.most_common(10), 1):
markdown += f"{i}. **{keyword}** - 出现 {count} 次\n"
# 平台分析
markdown += "\n## 📱 平台活跃度\n\n"
sorted_platforms = sorted(all_platforms_news.items(), key=lambda x: x[1], reverse=True)
for platform, count in sorted_platforms:
markdown += f"- **{platform}**: {count} 条新闻\n"
# 趋势变化（如果是周报）
if report_type == "weekly":
markdown += "\n## 📈 趋势分析\n\n"
markdown += "本周热度持续的话题（样本数据）：\n\n"
# 简单的趋势分析
top_keywords = [kw for kw, _ in all_keywords.most_common(5)]
for keyword in top_keywords:
markdown += f"- **{keyword}**: 持续热门\n"
# 添加样本新闻（按权重选择，确保确定性）
markdown += "\n## 📰 精选新闻样本\n\n"
# 确定性选取：按标题的权重排序，取前5条
# 这样相同输入总是返回相同结果
if all_titles_list:
# 计算每条新闻的权重分数（基于关键词出现次数）
news_with_scores = []
for news in all_titles_list:
# 简单权重：统计包含TOP关键词的次数
score = 0
title_lower = news['title'].lower()
for keyword, count in all_keywords.most_common(10):
if keyword.lower() in title_lower:
score += count
news_with_scores.append((news, score))
# 按权重降序排序，权重相同则按标题字母顺序（确保确定性）
news_with_scores.sort(key=lambda x: (-x[1], x[0]['title']))
# 取前5条
sample_news = [item[0] for item in news_with_scores[:5]]
for news in sample_news:
markdown += f"- [{news['platform']}] {news['title']}\n"
markdown += "\n---\n\n*本报告由 TrendRadar MCP 自动生成*\n"
return {
"success": True,
"report_type": report_type,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d")
},
"markdown_report": markdown,
"statistics": {
"total_news": len(all_titles_list),
"platforms_count": len(all_platforms_news),
"keywords_count": len(all_keywords),
"top_keyword": all_keywords.most_common(1)[0] if all_keywords else None
}
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def get_platform_activity_stats(
self,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
try:
# 参数验证
date_range_tuple = validate_date_range(date_range)
# 确定日期范围
if date_range_tuple:
start_date, end_date = date_range_tuple
else:
start_date = end_date = datetime.now()
# 统计各平台活跃度
platform_activity = defaultdict(lambda: {
"total_updates": 0,
"days_active": set(),
"news_count": 0,
"hourly_distribution": Counter()
})
# 遍历日期范围
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, timestamps = self.data_service.parser.read_all_titles_for_date(
date=current_date
)
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
platform_activity[platform_name]["news_count"] += len(titles)
platform_activity[platform_name]["days_active"].add(current_date.strftime("%Y-%m-%d"))
# 统计更新次数（基于文件数量）
platform_activity[platform_name]["total_updates"] += len(timestamps)
# 统计时间分布（基于文件名中的时间）
for filename in timestamps.keys():
# 解析文件名中的小时（格式：HHMM.txt）
match = re.match(r'(\d{2})(\d{2})\.txt', filename)
if match:
hour = int(match.group(1))
platform_activity[platform_name]["hourly_distribution"][hour] += 1
except DataNotFoundError:
pass
current_date += timedelta(days=1)
# 转换为可序列化的格式
result_activity = {}
for platform, stats in platform_activity.items():
days_count = len(stats["days_active"])
avg_news_per_day = stats["news_count"] / days_count if days_count > 0 else 0
# 找出最活跃的时间段
most_active_hours = stats["hourly_distribution"].most_common(3)
result_activity[platform] = {
"total_updates": stats["total_updates"],
"news_count": stats["news_count"],
"days_active": days_count,
"avg_news_per_day": round(avg_news_per_day, 2),
"most_active_hours": [
{"hour": f"{hour:02d}:00", "count": count}
for hour, count in most_active_hours
],
"activity_score": round(stats["news_count"] / max(days_count, 1), 2)
}
# 按活跃度排序
sorted_platforms = sorted(
result_activity.items(),
key=lambda x: x[1]["activity_score"],
reverse=True
)
return {
"success": True,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d")
},
"platform_activity": dict(sorted_platforms),
"most_active_platform": sorted_platforms[0][0] if sorted_platforms else None,
"total_platforms": len(result_activity)
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def analyze_topic_lifecycle(
self,
topic: str,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
try:
# 参数验证
topic = validate_keyword(topic)
# 处理日期范围（不指定时默认最近7天）
if date_range:
from ..utils.validators import validate_date_range
date_range_tuple = validate_date_range(date_range)
start_date, end_date = date_range_tuple
else:
# 默认最近7天
end_date = datetime.now()
start_date = end_date - timedelta(days=6)
# 收集话题历史数据
lifecycle_data = []
current_date = start_date
while current_date <= end_date:
try:
all_titles, _, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date
)
# 统计该日的话题出现次数
count = 0
for _, titles in all_titles.items():
for title in titles.keys():
if topic.lower() in title.lower():
count += 1
lifecycle_data.append({
"date": current_date.strftime("%Y-%m-%d"),
"count": count
})
except DataNotFoundError:
lifecycle_data.append({
"date": current_date.strftime("%Y-%m-%d"),
"count": 0
})
current_date += timedelta(days=1)
# 计算分析天数
total_days = (end_date - start_date).days + 1
# 分析生命周期阶段
counts = [item["count"] for item in lifecycle_data]
if not any(counts):
time_desc = f"{start_date.strftime('%Y-%m-%d')} 至 {end_date.strftime('%Y-%m-%d')}"
raise DataNotFoundError(
f"在 {time_desc} 内未找到话题 '{topic}'",
suggestion="请尝试其他话题或扩大时间范围"
)
# 找到首次出现和最后出现
first_appearance = next((item["date"] for item in lifecycle_data if item["count"] > 0), None)
last_appearance = next((item["date"] for item in reversed(lifecycle_data) if item["count"] > 0), None)
# 计算峰值
max_count = max(counts)
peak_index = counts.index(max_count)
peak_date = lifecycle_data[peak_index]["date"]
# 计算平均值和标准差（简单实现）
non_zero_counts = [c for c in counts if c > 0]
avg_count = sum(non_zero_counts) / len(non_zero_counts) if non_zero_counts else 0
# 判断生命周期阶段
recent_counts = counts[-3:] # 最近3天
early_counts = counts[:3] # 前3天
if sum(recent_counts) > sum(early_counts):
lifecycle_stage = "上升期"
elif sum(recent_counts) < sum(early_counts) * 0.5:
lifecycle_stage = "衰退期"
elif max_count in recent_counts:
lifecycle_stage = "爆发期"
else:
lifecycle_stage = "稳定期"
# 分类：昙花一现 vs 持续热点
active_days = sum(1 for c in counts if c > 0)
if active_days <= 2 and max_count > avg_count * 2:
topic_type = "昙花一现"
elif active_days >= total_days * 0.6:
topic_type = "持续热点"
else:
topic_type = "周期性热点"
return {
"success": True,
"topic": topic,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d"),
"total_days": total_days
},
"lifecycle_data": lifecycle_data,
"analysis": {
"first_appearance": first_appearance,
"last_appearance": last_appearance,
"peak_date": peak_date,
"peak_count": max_count,
"active_days": active_days,
"avg_daily_mentions": round(avg_count, 2),
"lifecycle_stage": lifecycle_stage,
"topic_type": topic_type
}
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def detect_viral_topics(
self,
threshold: float = 3.0,
time_window: int = 24
) -> Dict:
try:
# 参数验证
threshold = validate_threshold(threshold, default=3.0, min_value=1.0, max_value=100.0)
time_window = validate_limit(time_window, default=24, max_limit=72)
# 读取当前和之前的数据
current_all_titles, _, _ = self.data_service.parser.read_all_titles_for_date()
# 读取昨天的数据作为基准
yesterday = datetime.now() - timedelta(days=1)
try:
previous_all_titles, _, _ = self.data_service.parser.read_all_titles_for_date(
date=yesterday
)
except DataNotFoundError:
previous_all_titles = {}
# 统计当前的关键词频率
current_keywords = Counter()
current_keyword_titles = defaultdict(list)
for _, titles in current_all_titles.items():
for title in titles.keys():
keywords = self._extract_keywords(title)
current_keywords.update(keywords)
for kw in keywords:
current_keyword_titles[kw].append(title)
# 统计之前的关键词频率
previous_keywords = Counter()
for _, titles in previous_all_titles.items():
for title in titles.keys():
keywords = self._extract_keywords(title)
previous_keywords.update(keywords)
# 检测异常热度
viral_topics = []
for keyword, current_count in current_keywords.items():
previous_count = previous_keywords.get(keyword, 0)
# 计算增长倍数
if previous_count == 0:
# 新出现的话题
if current_count >= 5: # 至少出现5次才认为是爆火
growth_rate = float('inf')
is_viral = True
else:
continue
else:
growth_rate = current_count / previous_count
is_viral = growth_rate >= threshold
if is_viral:
viral_topics.append({
"keyword": keyword,
"current_count": current_count,
"previous_count": previous_count,
"growth_rate": round(growth_rate, 2) if growth_rate != float('inf') else "新话题",
"sample_titles": current_keyword_titles[keyword][:3],
"alert_level": "高" if growth_rate > threshold * 2 else "中"
})
# 按增长率排序
viral_topics.sort(
key=lambda x: x["current_count"] if x["growth_rate"] == "新话题" else x["growth_rate"],
reverse=True
)
if not viral_topics:
return {
"success": True,
"summary": {
"description": "异常热度检测结果",
"total": 0,
"threshold": threshold,
"time_window": time_window
},
"data": [],
"message": f"未检测到热度增长超过 {threshold} 倍的话题"
}
return {
"success": True,
"summary": {
"description": "异常热度检测结果",
"total": len(viral_topics),
"threshold": threshold,
"time_window": time_window,
"detection_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
},
"data": viral_topics
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
def predict_trending_topics(
self,
lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> Dict:
try:
# 参数验证
lookahead_hours = validate_limit(lookahead_hours, default=6, max_limit=48)
confidence_threshold = validate_threshold(
confidence_threshold,
default=0.7,
min_value=0.0,
max_value=1.0,
param_name="confidence_threshold"
)
# 收集最近3天的数据用于预测
keyword_trends = defaultdict(list)
for days_ago in range(3, 0, -1):
date = datetime.now() - timedelta(days=days_ago)
try:
all_titles, _, _ = self.data_service.parser.read_all_titles_for_date(
date=date
)
# 统计关键词
keywords_count = Counter()
for _, titles in all_titles.items():
for title in titles.keys():
keywords = self._extract_keywords(title)
keywords_count.update(keywords)
# 记录每个关键词的历史数据
for keyword, count in keywords_count.items():
keyword_trends[keyword].append(count)
except DataNotFoundError:
pass
# 添加今天的数据
try:
all_titles, _, _ = self.data_service.parser.read_all_titles_for_date()
keywords_count = Counter()
keyword_titles = defaultdict(list)
for _, titles in all_titles.items():
for title in titles.keys():
keywords = self._extract_keywords(title)
keywords_count.update(keywords)
for kw in keywords:
keyword_titles[kw].append(title)
for keyword, count in keywords_count.items():
keyword_trends[keyword].append(count)
except DataNotFoundError:
raise DataNotFoundError(
"未找到今天的数据",
suggestion="请等待爬虫任务完成"
)
# 预测潜力话题
predicted_topics = []
for keyword, trend_data in keyword_trends.items():
if len(trend_data) < 2:
continue
# 简单的线性趋势预测
# 计算增长率
recent_value = trend_data[-1]
previous_value = trend_data[-2] if len(trend_data) >= 2 else 0
if previous_value == 0:
if recent_value >= 3:
growth_rate = 1.0
else:
continue
else:
growth_rate = (recent_value - previous_value) / previous_value
# 判断是否是上升趋势
if growth_rate > 0.3: # 增长超过30%
# 计算置信度（基于趋势的稳定性）
if len(trend_data) >= 3:
# 检查是否连续增长
is_consistent = all(
trend_data[i] <= trend_data[i+1]
for i in range(len(trend_data)-1)
)
confidence = 0.9 if is_consistent else 0.7
else:
confidence = 0.6
if confidence >= confidence_threshold:
predicted_topics.append({
"keyword": keyword,
"current_count": recent_value,
"growth_rate": round(growth_rate * 100, 2),
"confidence": round(confidence, 2),
"trend_data": trend_data,
"prediction": "上升趋势，可能成为热点",
"sample_titles": keyword_titles.get(keyword, [])[:3]
})
# 按置信度和增长率排序
predicted_topics.sort(
key=lambda x: (x["confidence"], x["growth_rate"]),
reverse=True
)
return {
"success": True,
"summary": {
"description": "热点话题预测结果",
"total": len(predicted_topics),
"returned": min(20, len(predicted_topics)),
"lookahead_hours": lookahead_hours,
"confidence_threshold": confidence_threshold,
"prediction_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
},
"data": predicted_topics[:20], # 返回TOP 20
"note": "预测基于历史趋势，实际结果可能有偏差"
}
except MCPError as e:
return {
"success": False,
"error": e.to_dict()
}
except Exception as e:
return {
"success": False,
"error": {
"code": "INTERNAL_ERROR",
"message": str(e)
}
}
# ==================== 辅助方法 ====================
def _extract_keywords(self, title: str, min_length: int = 2) -> List[str]:
# 移除URL和特殊字符
title = re.sub(r'http[s]?://\S+', '', title)
title = re.sub(r'[^\w\s]', ' ', title)
# 简单分词（按空格和常见分隔符）
words = re.split(r'[\s，。！？、]+', title)
# 过滤停用词和短词
stopwords = {'的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这'}
keywords = [
word.strip() for word in words
if word.strip() and len(word.strip()) >= min_length and word.strip() not in stopwords
]
return keywords
def _calculate_similarity(self, text1: str, text2: str) -> float:
# 使用 SequenceMatcher 计算相似度
return SequenceMatcher(None, text1, text2).ratio()
def _find_unique_topics(self, platform_stats: Dict) -> Dict[str, List[str]]:
unique_topics = {}
# 获取每个平台的TOP关键词
platform_keywords = {}
for platform, stats in platform_stats.items():
top_keywords = set([kw for kw, _ in stats["top_keywords"].most_common(10)])
platform_keywords[platform] = top_keywords
# 找出独有关键词
for platform, keywords in platform_keywords.items():
# 找出其他平台的所有关键词
other_keywords = set()
for other_platform, other_kws in platform_keywords.items():
if other_platform != platform:
other_keywords.update(other_kws)
# 找出独有的
unique = keywords - other_keywords
if unique:
unique_topics[platform] = list(unique)[:5] # 最多5个
return unique_topics
# ==================== 跨平台聚合工具 ====================
def aggregate_news(
self,
date_range: Optional[Union[Dict[str, str], str]] = None,
platforms: Optional[List[str]] = None,
similarity_threshold: float = 0.7,
limit: int = 50,
include_url: bool = False
) -> Dict:
try:
# 参数验证
platforms = validate_platforms(platforms)
similarity_threshold = validate_threshold(
similarity_threshold, default=0.7, min_value=0.3, max_value=1.0
)
limit = validate_limit(limit, default=50)
# 处理日期范围
if date_range:
date_range_tuple = validate_date_range(date_range)
start_date, end_date = date_range_tuple
else:
start_date = end_date = datetime.now()
# 收集所有新闻
all_news = []
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date,
platform_ids=platforms
)
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
news_item = {
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"date": current_date.strftime("%Y-%m-%d"),
"ranks": info.get("ranks", []),
"count": len(info.get("ranks", [])),
"rank": info["ranks"][0] if info["ranks"] else 999
}
if include_url:
news_item["url"] = info.get("url", "")
news_item["mobileUrl"] = info.get("mobileUrl", "")
# 计算权重
news_item["weight"] = calculate_news_weight(news_item)
all_news.append(news_item)
except DataNotFoundError:
pass
current_date += timedelta(days=1)
if not all_news:
return {
"success": True,
"summary": {
"description": "跨平台新闻聚合结果",
"total": 0,
"returned": 0
},
"data": [],
"message": "未找到新闻数据"
}
# 执行聚合
aggregated = self._aggregate_similar_news(
all_news, similarity_threshold, include_url
)
# 按综合权重排序
aggregated.sort(key=lambda x: x["aggregate_weight"], reverse=True)
# 限制返回数量
results = aggregated[:limit]
# 统计信息
total_original = len(all_news)
total_aggregated = len(aggregated)
dedup_rate = 1 - (total_aggregated / total_original) if total_original > 0 else 0
platform_coverage = Counter()
for item in aggregated:
for p in item["platforms"]:
platform_coverage[p] += 1
return {
"success": True,
"summary": {
"description": "跨平台新闻聚合结果",
"original_count": total_original,
"aggregated_count": total_aggregated,
"returned": len(results),
"deduplication_rate": f"{dedup_rate * 100:.1f}%",
"similarity_threshold": similarity_threshold,
"date_range": {
"start": start_date.strftime("%Y-%m-%d"),
"end": end_date.strftime("%Y-%m-%d")
}
},
"data": results,
"statistics": {
"platform_coverage": dict(platform_coverage),
"multi_platform_news": len([a for a in aggregated if len(a["platforms"]) > 1]),
"single_platform_news": len([a for a in aggregated if len(a["platforms"]) == 1])
}
}
except MCPError as e:
return {"success": False, "error": e.to_dict()}
except Exception as e:
return {"success": False, "error": {"code": "INTERNAL_ERROR", "message": str(e)}}
def _aggregate_similar_news(
self,
news_list: List[Dict],
threshold: float,
include_url: bool
) -> List[Dict]:
if not news_list:
return []
# 预计算字符集合用于快速过滤
prepared_news = []
for news in news_list:
char_set = set(news["title"])
prepared_news.append({
"data": news,
"char_set": char_set,
"set_len": len(char_set)
})
# 按权重排序
sorted_items = sorted(prepared_news, key=lambda x: x["data"].get("weight", 0), reverse=True)
aggregated = []
used_indices = set()
PRE_FILTER_RATIO = 0.5 # 粗筛阈值系数
for i, item in enumerate(sorted_items):
if i in used_indices:
continue
news = item["data"]
base_set = item["char_set"]
base_len = item["set_len"]
group = {
"representative_title": news["title"],
"platforms": [news["platform_name"]],
"platform_ids": [news["platform"]],
"dates": [news["date"]],
"best_rank": news["rank"],
"total_count": news["count"],
"aggregate_weight": news.get("weight", 0),
"sources": [{
"platform": news["platform_name"],
"rank": news["rank"],
"date": news["date"]
}]
}
if include_url and news.get("url"):
group["urls"] = [{
"platform": news["platform_name"],
"url": news.get("url", ""),
"mobileUrl": news.get("mobileUrl", "")
}]
used_indices.add(i)
# 查找相似新闻
for j in range(i + 1, len(sorted_items)):
if j in used_indices:
continue
compare_item = sorted_items[j]
compare_set = compare_item["char_set"]
compare_len = compare_item["set_len"]
# 快速粗筛：长度检查
if base_len == 0 or compare_len == 0:
continue
# 快速粗筛：长度比例检查
if min(base_len, compare_len) / max(base_len, compare_len) < (threshold * PRE_FILTER_RATIO):
continue
# 快速粗筛：Jaccard 相似度
intersection = len(base_set & compare_set)
union = len(base_set | compare_set)
jaccard_sim = intersection / union if union > 0 else 0
if jaccard_sim < (threshold * PRE_FILTER_RATIO):
continue
# 精确计算：SequenceMatcher
other_news = compare_item["data"]
real_similarity = self._calculate_similarity(news["title"], other_news["title"])
if real_similarity >= threshold:
# 合并到当前组
if other_news["platform_name"] not in group["platforms"]:
group["platforms"].append(other_news["platform_name"])
group["platform_ids"].append(other_news["platform"])
if other_news["date"] not in group["dates"]:
group["dates"].append(other_news["date"])
group["best_rank"] = min(group["best_rank"], other_news["rank"])
group["total_count"] += other_news["count"]
group["aggregate_weight"] += other_news.get("weight", 0) * 0.5 # 额外权重
group["sources"].append({
"platform": other_news["platform_name"],
"rank": other_news["rank"],
"date": other_news["date"]
})
if include_url and other_news.get("url"):
if "urls" not in group:
group["urls"] = []
group["urls"].append({
"platform": other_news["platform_name"],
"url": other_news.get("url", ""),
"mobileUrl": other_news.get("mobileUrl", "")
})
used_indices.add(j)
# 添加聚合信息
group["platform_count"] = len(group["platforms"])
group["is_cross_platform"] = len(group["platforms"]) > 1
aggregated.append(group)
return aggregated
# ==================== 时期对比分析工具 ====================
def compare_periods(
self,
period1: Union[Dict[str, str], str],
period2: Union[Dict[str, str], str],
topic: Optional[str] = None,
compare_type: str = "overview",
platforms: Optional[List[str]] = None,
top_n: int = 10
) -> Dict:
try:
# 参数验证
platforms = validate_platforms(platforms)
top_n = validate_top_n(top_n, default=10)
if compare_type not in ["overview", "topic_shift", "platform_activity"]:
raise InvalidParameterError(
f"不支持的对比类型: {compare_type}",
suggestion="支持的类型: overview, topic_shift, platform_activity"
)
# 解析时间段
date_range1 = self._parse_period(period1)
date_range2 = self._parse_period(period2)
if not date_range1 or not date_range2:
raise InvalidParameterError(
"无效的时间段格式",
suggestion="使用 {'start': 'YYYY-MM-DD', 'end': 'YYYY-MM-DD'} 或预设值如 'last_week'"
)
# 收集两个时期的数据
data1 = self._collect_period_data(date_range1, platforms, topic)
data2 = self._collect_period_data(date_range2, platforms, topic)
# 根据对比类型执行不同的分析
if compare_type == "overview":
analysis_result = self._compare_overview(data1, data2, date_range1, date_range2, top_n)
elif compare_type == "topic_shift":
analysis_result = self._compare_topic_shift(data1, data2, date_range1, date_range2, top_n)
else: # platform_activity
analysis_result = self._compare_platform_activity(data1, data2, date_range1, date_range2)
result = {
"success": True,
"summary": {
"description": f"时期对比分析（{compare_type}）",
"compare_type": compare_type,
"periods": {
"period1": {
"start": date_range1[0].strftime("%Y-%m-%d"),
"end": date_range1[1].strftime("%Y-%m-%d")
},
"period2": {
"start": date_range2[0].strftime("%Y-%m-%d"),
"end": date_range2[1].strftime("%Y-%m-%d")
}
}
},
"data": analysis_result
}
if topic:
result["summary"]["topic_filter"] = topic
return result
except MCPError as e:
return {"success": False, "error": e.to_dict()}
except Exception as e:
return {"success": False, "error": {"code": "INTERNAL_ERROR", "message": str(e)}}
def _parse_period(self, period: Union[Dict[str, str], str]) -> Optional[tuple]:
today = datetime.now()
if isinstance(period, str):
if period == "today":
return (today, today)
elif period == "yesterday":
yesterday = today - timedelta(days=1)
return (yesterday, yesterday)
elif period == "last_week":
return (today - timedelta(days=7), today - timedelta(days=1))
elif period == "this_week":
# 本周一到今天
days_since_monday = today.weekday()
monday = today - timedelta(days=days_since_monday)
return (monday, today)
elif period == "last_month":
return (today - timedelta(days=30), today - timedelta(days=1))
elif period == "this_month":
first_of_month = today.replace(day=1)
return (first_of_month, today)
else:
return None
elif isinstance(period, dict):
try:
start = datetime.strptime(period["start"], "%Y-%m-%d")
end = datetime.strptime(period["end"], "%Y-%m-%d")
return (start, end)
except (KeyError, ValueError):
return None
return None
def _collect_period_data(
self,
date_range: tuple,
platforms: Optional[List[str]],
topic: Optional[str]
) -> Dict:
start_date, end_date = date_range
all_news = []
all_keywords = Counter()
platform_stats = Counter()
current_date = start_date
while current_date <= end_date:
try:
all_titles, id_to_name, _ = self.data_service.parser.read_all_titles_for_date(
date=current_date,
platform_ids=platforms
)
for platform_id, titles in all_titles.items():
platform_name = id_to_name.get(platform_id, platform_id)
for title, info in titles.items():
# 如果指定了话题，过滤不相关的新闻
if topic and topic.lower() not in title.lower():
continue
news_item = {
"title": title,
"platform": platform_id,
"platform_name": platform_name,
"date": current_date.strftime("%Y-%m-%d"),
"ranks": info.get("ranks", []),
"rank": info["ranks"][0] if info["ranks"] else 999
}
news_item["weight"] = calculate_news_weight(news_item)
all_news.append(news_item)
# 统计平台
platform_stats[platform_name] += 1
# 提取关键词
keywords = self._extract_keywords(title)
all_keywords.update(keywords)
except DataNotFoundError:
pass
current_date += timedelta(days=1)
return {
"news": all_news,
"news_count": len(all_news),
"keywords": all_keywords,
"platform_stats": platform_stats,
"date_range": date_range
}
def _compare_overview(
self,
data1: Dict,
data2: Dict,
range1: tuple,
range2: tuple,
top_n: int
) -> Dict:
# 计算变化
count_change = data2["news_count"] - data1["news_count"]
count_change_pct = (count_change / data1["news_count"] * 100) if data1["news_count"] > 0 else 0
# TOP 关键词对比
top_kw1 = [kw for kw, _ in data1["keywords"].most_common(top_n)]
top_kw2 = [kw for kw, _ in data2["keywords"].most_common(top_n)]
new_keywords = [kw for kw in top_kw2 if kw not in top_kw1]
disappeared_keywords = [kw for kw in top_kw1 if kw not in top_kw2]
persistent_keywords = [kw for kw in top_kw1 if kw in top_kw2]
# TOP 新闻对比
top_news1 = sorted(data1["news"], key=lambda x: x.get("weight", 0), reverse=True)[:top_n]
top_news2 = sorted(data2["news"], key=lambda x: x.get("weight", 0), reverse=True)[:top_n]
return {
"overview": {
"period1_count": data1["news_count"],
"period2_count": data2["news_count"],
"count_change": count_change,
"count_change_percent": f"{count_change_pct:+.1f}%"
},
"keyword_analysis": {
"new_keywords": new_keywords[:5],
"disappeared_keywords": disappeared_keywords[:5],
"persistent_keywords": persistent_keywords[:5]
},
"top_news": {
"period1": [{"title": n["title"], "platform": n["platform_name"]} for n in top_news1],
"period2": [{"title": n["title"], "platform": n["platform_name"]} for n in top_news2]
}
}
def _compare_topic_shift(
self,
data1: Dict,
data2: Dict,
range1: tuple,
range2: tuple,
top_n: int
) -> Dict:
kw1 = data1["keywords"]
kw2 = data2["keywords"]
# 计算热度变化
all_keywords = set(kw1.keys()) | set(kw2.keys())
keyword_changes = []
for kw in all_keywords:
count1 = kw1.get(kw, 0)
count2 = kw2.get(kw, 0)
change = count2 - count1
if count1 > 0:
change_pct = (change / count1) * 100
elif count2 > 0:
change_pct = 100 # 新出现
else:
change_pct = 0
keyword_changes.append({
"keyword": kw,
"period1_count": count1,
"period2_count": count2,
"change": change,
"change_percent": round(change_pct, 1)
})
# 按变化幅度排序
rising = sorted([k for k in keyword_changes if k["change"] > 0],
key=lambda x: x["change"], reverse=True)[:top_n]
falling = sorted([k for k in keyword_changes if k["change"] < 0],
key=lambda x: x["change"])[:top_n]
new_topics = [k for k in keyword_changes if k["period1_count"] == 0 and k["period2_count"] > 0][:top_n]
return {
"rising_topics": rising,
"falling_topics": falling,
"new_topics": new_topics,
"total_keywords": {
"period1": len(kw1),
"period2": len(kw2)
}
}
def _compare_platform_activity(
self,
data1: Dict,
data2: Dict,
range1: tuple,
range2: tuple
) -> Dict:
ps1 = data1["platform_stats"]
ps2 = data2["platform_stats"]
all_platforms = set(ps1.keys()) | set(ps2.keys())
platform_changes = []
for platform in all_platforms:
count1 = ps1.get(platform, 0)
count2 = ps2.get(platform, 0)
change = count2 - count1
if count1 > 0:
change_pct = (change / count1) * 100
elif count2 > 0:
change_pct = 100
else:
change_pct = 0
platform_changes.append({
"platform": platform,
"period1_count": count1,
"period2_count": count2,
"change": change,
"change_percent": round(change_pct, 1)
})
# 按变化排序
platform_changes.sort(key=lambda x: x["change"], reverse=True)
return {
"platform_comparison": platform_changes,
"most_active_growth": platform_changes[0] if platform_changes else None,
"least_active_growth": platform_changes[-1] if platform_changes else None,
"total_activity": {
"period1": sum(ps1.values()),
"period2": sum(ps2.values())
}
} | --- +++ @@ -1,3 +1,8 @@+"""
+高级数据分析工具
+
+提供热度趋势分析、平台对比、关键词共现、情感分析等高级分析功能。
+"""
import os
import re
@@ -35,6 +40,14 @@
def _get_weight_config() -> Dict:
+ """
+ 从 config.yaml 读取权重配置（带 mtime 缓存）
+
+ 仅当配置文件被修改时才重新读取，避免循环内重复 IO。
+
+ Returns:
+ 权重配置字典，包含 RANK_WEIGHT, FREQUENCY_WEIGHT, HOTNESS_WEIGHT
+ """
global _weight_config_cache, _weight_config_mtime, _weight_config_path
try:
@@ -67,12 +80,32 @@
def calculate_news_weight(news_data: Dict, rank_threshold: int = 5) -> float:
+ """
+ 计算新闻权重（用于排序）
+
+ 复用 trendradar.core.analyzer.calculate_news_weight 实现，
+ 权重配置从 config.yaml 的 advanced.weight 读取。
+
+ Args:
+ news_data: 新闻数据字典，包含 ranks 和 count 字段
+ rank_threshold: 高排名阈值，默认5
+
+ Returns:
+ 权重分数（0-100之间的浮点数）
+ """
return _calculate_news_weight(news_data, rank_threshold, _get_weight_config())
class AnalyticsTools:
+ """高级数据分析工具类"""
def __init__(self, project_root: str = None):
+ """
+ 初始化分析工具
+
+ Args:
+ project_root: 项目根目录
+ """
self.data_service = DataService(project_root)
def analyze_data_insights_unified(
@@ -83,6 +116,27 @@ min_frequency: int = 3,
top_n: int = 20
) -> Dict:
+ """
+ 统一数据洞察分析工具 - 整合多种数据分析模式
+
+ Args:
+ insight_type: 洞察类型，可选值：
+ - "platform_compare": 平台对比分析（对比不同平台对话题的关注度）
+ - "platform_activity": 平台活跃度统计（统计各平台发布频率和活跃时间）
+ - "keyword_cooccur": 关键词共现分析（分析关键词同时出现的模式）
+ topic: 话题关键词（可选，platform_compare模式适用）
+ date_range: 日期范围，格式: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ min_frequency: 最小共现频次（keyword_cooccur模式），默认3
+ top_n: 返回TOP N结果（keyword_cooccur模式），默认20
+
+ Returns:
+ 数据洞察分析结果字典
+
+ Examples:
+ - analyze_data_insights_unified(insight_type="platform_compare", topic="人工智能")
+ - analyze_data_insights_unified(insight_type="platform_activity", date_range={...})
+ - analyze_data_insights_unified(insight_type="keyword_cooccur", min_frequency=5)
+ """
try:
# 参数验证
if insight_type not in ["platform_compare", "platform_activity", "keyword_cooccur"]:
@@ -132,6 +186,34 @@ lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> Dict:
+ """
+ 统一话题趋势分析工具 - 整合多种趋势分析模式
+
+ Args:
+ topic: 话题关键词（必需）
+ analysis_type: 分析类型，可选值：
+ - "trend": 热度趋势分析（追踪话题的热度变化）
+ - "lifecycle": 生命周期分析（从出现到消失的完整周期）
+ - "viral": 异常热度检测（识别突然爆火的话题）
+ - "predict": 话题预测（预测未来可能的热点）
+ date_range: 日期范围（trend和lifecycle模式），可选
+ - **格式**: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ - **默认**: 不指定时默认分析最近7天
+ granularity: 时间粒度（trend模式），默认"day"（hour/day）
+ threshold: 热度突增倍数阈值（viral模式），默认3.0
+ time_window: 检测时间窗口小时数（viral模式），默认24
+ lookahead_hours: 预测未来小时数（predict模式），默认6
+ confidence_threshold: 置信度阈值（predict模式），默认0.7
+
+ Returns:
+ 趋势分析结果字典
+
+ Examples (假设今天是 2025-11-17):
+ - 用户："分析AI最近7天的趋势" → analyze_topic_trend_unified(topic="人工智能", analysis_type="trend", date_range={"start": "2025-11-11", "end": "2025-11-17"})
+ - 用户："看看特斯拉本月的热度" → analyze_topic_trend_unified(topic="特斯拉", analysis_type="lifecycle", date_range={"start": "2025-11-01", "end": "2025-11-17"})
+ - analyze_topic_trend_unified(topic="比特币", analysis_type="viral", threshold=3.0)
+ - analyze_topic_trend_unified(topic="ChatGPT", analysis_type="predict", lookahead_hours=6)
+ """
try:
# 参数验证
topic = validate_keyword(topic)
@@ -187,6 +269,43 @@ date_range: Optional[Union[Dict[str, str], str]] = None,
granularity: str = "day"
) -> Dict:
+ """
+ 热度趋势分析 - 追踪特定话题的热度变化趋势
+
+ Args:
+ topic: 话题关键词
+ date_range: 日期范围（可选）
+ - **格式**: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ - **默认**: 不指定时默认分析最近7天
+ granularity: 时间粒度，仅支持 day（天）
+
+ Returns:
+ 趋势分析结果字典
+
+ Examples:
+ 用户询问示例：
+ - "帮我分析一下'人工智能'这个话题最近一周的热度趋势"
+ - "查看'比特币'过去一周的热度变化"
+ - "看看'iPhone'最近7天的趋势如何"
+ - "分析'特斯拉'最近一个月的热度趋势"
+ - "查看'ChatGPT'2024年12月的趋势变化"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> # 分析7天趋势（假设今天是 2025-11-17）
+ >>> result = tools.get_topic_trend_analysis(
+ ... topic="人工智能",
+ ... date_range={"start": "2025-11-11", "end": "2025-11-17"},
+ ... granularity="day"
+ ... )
+ >>> # 分析历史月份趋势
+ >>> result = tools.get_topic_trend_analysis(
+ ... topic="特斯拉",
+ ... date_range={"start": "2024-12-01", "end": "2024-12-31"},
+ ... granularity="day"
+ ... )
+ >>> print(result['trend_data'])
+ """
try:
# 验证参数
topic = validate_keyword(topic)
@@ -308,6 +427,30 @@ topic: Optional[str] = None,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
+ """
+ 平台对比分析 - 对比不同平台对同一话题的关注度
+
+ Args:
+ topic: 话题关键词（可选，不指定则对比整体活跃度）
+ date_range: 日期范围，格式: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+
+ Returns:
+ 平台对比分析结果
+
+ Examples:
+ 用户询问示例：
+ - "对比一下各个平台对'人工智能'话题的关注度"
+ - "看看知乎和微博哪个平台更关注科技新闻"
+ - "分析各平台今天的热点分布"
+
+ 代码调用示例：
+ >>> # 对比各平台（假设今天是 2025-11-17）
+ >>> result = tools.compare_platforms(
+ ... topic="人工智能",
+ ... date_range={"start": "2025-11-08", "end": "2025-11-17"}
+ ... )
+ >>> print(result['platform_stats'])
+ """
try:
# 参数验证
if topic:
@@ -408,6 +551,30 @@ min_frequency: int = 3,
top_n: int = 20
) -> Dict:
+ """
+ 关键词共现分析 - 分析哪些关键词经常同时出现
+
+ Args:
+ min_frequency: 最小共现频次
+ top_n: 返回TOP N关键词对
+
+ Returns:
+ 关键词共现分析结果
+
+ Examples:
+ 用户询问示例：
+ - "分析一下哪些关键词经常一起出现"
+ - "看看'人工智能'经常和哪些词一起出现"
+ - "找出今天新闻中的关键词关联"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.analyze_keyword_cooccurrence(
+ ... min_frequency=5,
+ ... top_n=15
+ ... )
+ >>> print(result['cooccurrence_pairs'])
+ """
try:
# 参数验证
min_frequency = validate_limit(min_frequency, default=3, max_limit=100)
@@ -496,6 +663,45 @@ sort_by_weight: bool = True,
include_url: bool = False
) -> Dict:
+ """
+ 情感倾向分析 - 生成用于 AI 情感分析的结构化提示词
+
+ 本工具收集新闻数据并生成优化的 AI 提示词，你可以将其发送给 AI 进行深度情感分析。
+
+ Args:
+ topic: 话题关键词（可选），只分析包含该关键词的新闻
+ platforms: 平台过滤列表（可选），如 ['zhihu', 'weibo']
+ date_range: 日期范围（可选），格式: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ 不指定则默认查询今天的数据
+ limit: 返回新闻数量限制，默认50，最大100
+ sort_by_weight: 是否按权重排序，默认True（推荐）
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ 包含 AI 提示词和新闻数据的结构化结果
+
+ Examples:
+ 用户询问示例：
+ - "分析一下今天新闻的情感倾向"
+ - "看看'特斯拉'相关新闻是正面还是负面的"
+ - "分析各平台对'人工智能'的情感态度"
+ - "看看'特斯拉'相关新闻是正面还是负面的，请选择一周内的前10条新闻来分析"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> # 分析今天的特斯拉新闻，返回前10条
+ >>> result = tools.analyze_sentiment(
+ ... topic="特斯拉",
+ ... limit=10
+ ... )
+ >>> # 分析一周内的特斯拉新闻（假设今天是 2025-11-17）
+ >>> result = tools.analyze_sentiment(
+ ... topic="特斯拉",
+ ... date_range={"start": "2025-11-11", "end": "2025-11-17"},
+ ... limit=10
+ ... )
+ >>> print(result['ai_prompt']) # 获取生成的提示词
+ """
try:
# 参数验证
if topic:
@@ -641,6 +847,16 @@ news_data: List[Dict],
topic: Optional[str]
) -> str:
+ """
+ 创建情感分析的 AI 提示词
+
+ Args:
+ news_data: 新闻数据列表（已排序和限制数量）
+ topic: 话题关键词
+
+ Returns:
+ 格式化的 AI 提示词
+ """
# 按平台分组
platform_news = defaultdict(list)
for item in news_data:
@@ -725,6 +941,33 @@ limit: int = 50,
include_url: bool = False
) -> Dict:
+ """
+ 相似新闻查找 - 基于标题相似度查找相关新闻
+
+ Args:
+ reference_title: 参考标题
+ threshold: 相似度阈值（0-1之间）
+ limit: 返回条数限制，默认50
+ include_url: 是否包含URL链接，默认False（节省token）
+
+ Returns:
+ 相似新闻列表
+
+ Examples:
+ 用户询问示例：
+ - "找出和'特斯拉降价'相似的新闻"
+ - "查找关于iPhone发布的类似报道"
+ - "看看有没有和这条新闻相似的报道"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.find_similar_news(
+ ... reference_title="特斯拉宣布降价",
+ ... threshold=0.6,
+ ... limit=10
+ ... )
+ >>> print(result['similar_news'])
+ """
try:
# 参数验证
reference_title = validate_keyword(reference_title)
@@ -813,6 +1056,33 @@ limit: int = 50,
sort_by_weight: bool = True
) -> Dict:
+ """
+ 实体识别搜索 - 搜索包含特定人物/地点/机构的新闻
+
+ Args:
+ entity: 实体名称
+ entity_type: 实体类型（person/location/organization），可选
+ limit: 返回条数限制，默认50，最大200
+ sort_by_weight: 是否按权重排序，默认True
+
+ Returns:
+ 实体相关新闻列表
+
+ Examples:
+ 用户询问示例：
+ - "搜索马斯克相关的新闻"
+ - "查找关于特斯拉公司的报道，返回前20条"
+ - "看看北京有什么新闻"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.search_by_entity(
+ ... entity="马斯克",
+ ... entity_type="person",
+ ... limit=20
+ ... )
+ >>> print(result['related_news'])
+ """
try:
# 参数验证
entity = validate_keyword(entity)
@@ -915,6 +1185,29 @@ report_type: str = "daily",
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
+ """
+ 每日/每周摘要生成器 - 自动生成热点摘要报告
+
+ Args:
+ report_type: 报告类型（daily/weekly）
+ date_range: 自定义日期范围（可选）
+
+ Returns:
+ Markdown格式的摘要报告
+
+ Examples:
+ 用户询问示例：
+ - "生成今天的新闻摘要报告"
+ - "给我一份本周的热点总结"
+ - "生成过去7天的新闻分析报告"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.generate_summary_report(
+ ... report_type="daily"
+ ... )
+ >>> print(result['markdown_report'])
+ """
try:
# 参数验证
if report_type not in ["daily", "weekly"]:
@@ -1071,6 +1364,28 @@ self,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
+ """
+ 平台活跃度统计 - 统计各平台的发布频率和活跃时间段
+
+ Args:
+ date_range: 日期范围（可选）
+
+ Returns:
+ 平台活跃度统计结果
+
+ Examples:
+ 用户询问示例：
+ - "统计各平台今天的活跃度"
+ - "看看哪个平台更新最频繁"
+ - "分析各平台的发布时间规律"
+
+ 代码调用示例：
+ >>> # 查看各平台活跃度（假设今天是 2025-11-17）
+ >>> result = tools.get_platform_activity_stats(
+ ... date_range={"start": "2025-11-08", "end": "2025-11-17"}
+ ... )
+ >>> print(result['platform_activity'])
+ """
try:
# 参数验证
date_range_tuple = validate_date_range(date_range)
@@ -1177,6 +1492,32 @@ topic: str,
date_range: Optional[Union[Dict[str, str], str]] = None
) -> Dict:
+ """
+ 话题生命周期分析 - 追踪话题从出现到消失的完整周期
+
+ Args:
+ topic: 话题关键词
+ date_range: 日期范围（可选）
+ - **格式**: {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}
+ - **默认**: 不指定时默认分析最近7天
+
+ Returns:
+ 话题生命周期分析结果
+
+ Examples:
+ 用户询问示例：
+ - "分析'人工智能'这个话题的生命周期"
+ - "看看'iPhone'话题是昙花一现还是持续热点"
+ - "追踪'比特币'话题的热度变化"
+
+ 代码调用示例：
+ >>> # 分析话题生命周期（假设今天是 2025-11-17）
+ >>> result = tools.analyze_topic_lifecycle(
+ ... topic="人工智能",
+ ... date_range={"start": "2025-10-19", "end": "2025-11-17"}
+ ... )
+ >>> print(result['lifecycle_stage'])
+ """
try:
# 参数验证
topic = validate_keyword(topic)
@@ -1309,6 +1650,30 @@ threshold: float = 3.0,
time_window: int = 24
) -> Dict:
+ """
+ 异常热度检测 - 自动识别突然爆火的话题
+
+ Args:
+ threshold: 热度突增倍数阈值
+ time_window: 检测时间窗口（小时）
+
+ Returns:
+ 爆火话题列表
+
+ Examples:
+ 用户询问示例：
+ - "检测今天有哪些突然爆火的话题"
+ - "看看有没有热度异常的新闻"
+ - "预警可能的重大事件"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.detect_viral_topics(
+ ... threshold=3.0,
+ ... time_window=24
+ ... )
+ >>> print(result['viral_topics'])
+ """
try:
# 参数验证
threshold = validate_threshold(threshold, default=3.0, min_value=1.0, max_value=100.0)
@@ -1424,6 +1789,30 @@ lookahead_hours: int = 6,
confidence_threshold: float = 0.7
) -> Dict:
+ """
+ 话题预测 - 基于历史数据预测未来可能的热点
+
+ Args:
+ lookahead_hours: 预测未来多少小时
+ confidence_threshold: 置信度阈值
+
+ Returns:
+ 预测的潜力话题列表
+
+ Examples:
+ 用户询问示例：
+ - "预测接下来6小时可能的热点话题"
+ - "有哪些话题可能会火起来"
+ - "早期发现潜力话题"
+
+ 代码调用示例：
+ >>> tools = AnalyticsTools()
+ >>> result = tools.predict_trending_topics(
+ ... lookahead_hours=6,
+ ... confidence_threshold=0.7
+ ... )
+ >>> print(result['predicted_topics'])
+ """
try:
# 参数验证
lookahead_hours = validate_limit(lookahead_hours, default=6, max_limit=48)
@@ -1565,6 +1954,16 @@ # ==================== 辅助方法 ====================
def _extract_keywords(self, title: str, min_length: int = 2) -> List[str]:
+ """
+ 从标题中提取关键词（简单实现）
+
+ Args:
+ title: 标题文本
+ min_length: 最小关键词长度
+
+ Returns:
+ 关键词列表
+ """
# 移除URL和特殊字符
title = re.sub(r'http[s]?://\S+', '', title)
title = re.sub(r'[^\w\s]', ' ', title)
@@ -1583,10 +1982,29 @@ return keywords
def _calculate_similarity(self, text1: str, text2: str) -> float:
+ """
+ 计算两个文本的相似度
+
+ Args:
+ text1: 文本1
+ text2: 文本2
+
+ Returns:
+ 相似度分数（0-1之间）
+ """
# 使用 SequenceMatcher 计算相似度
return SequenceMatcher(None, text1, text2).ratio()
def _find_unique_topics(self, platform_stats: Dict) -> Dict[str, List[str]]:
+ """
+ 找出各平台独有的热点话题
+
+ Args:
+ platform_stats: 平台统计数据
+
+ Returns:
+ 各平台独有话题字典
+ """
unique_topics = {}
# 获取每个平台的TOP关键词
@@ -1620,6 +2038,26 @@ limit: int = 50,
include_url: bool = False
) -> Dict:
+ """
+ 跨平台新闻聚合 - 对相似新闻进行去重合并
+
+ 将不同平台报道的同一事件合并为一条聚合新闻，
+ 显示该新闻在各平台的覆盖情况和综合热度。
+
+ Args:
+ date_range: 日期范围（可选）
+ - 不指定: 查询今天
+ - {\"start\": \"YYYY-MM-DD\", \"end\": \"YYYY-MM-DD\"}: 日期范围
+ platforms: 平台过滤列表，如 ['zhihu', 'weibo']
+ similarity_threshold: 相似度阈值，0-1之间，默认0.7
+ limit: 返回聚合新闻数量，默认50
+ include_url: 是否包含URL链接，默认False
+
+ Returns:
+ 聚合结果字典，包含：
+ - aggregated_news: 聚合后的新闻列表
+ - statistics: 聚合统计信息
+ """
try:
# 参数验证
platforms = validate_platforms(platforms)
@@ -1739,6 +2177,19 @@ threshold: float,
include_url: bool
) -> List[Dict]:
+ """
+ 对新闻列表进行相似度聚合
+
+ 使用双层过滤策略：先用 Jaccard 快速粗筛，再用 SequenceMatcher 精确计算
+
+ Args:
+ news_list: 新闻列表
+ threshold: 相似度阈值
+ include_url: 是否包含URL
+
+ Returns:
+ 聚合后的新闻列表
+ """
if not news_list:
return []
@@ -1869,6 +2320,27 @@ platforms: Optional[List[str]] = None,
top_n: int = 10
) -> Dict:
+ """
+ 时期对比分析 - 比较两个时间段的新闻数据
+
+ 支持多种对比维度：热度对比、话题变化、平台活跃度等。
+
+ Args:
+ period1: 第一个时间段
+ - {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}: 日期范围
+ - "today", "yesterday", "last_week", "last_month": 预设值
+ period2: 第二个时间段（格式同 period1）
+ topic: 可选的话题关键词（聚焦特定话题的对比）
+ compare_type: 对比类型
+ - "overview": 总体概览（默认）
+ - "topic_shift": 话题变化分析
+ - "platform_activity": 平台活跃度对比
+ platforms: 平台过滤列表
+ top_n: 返回 TOP N 结果，默认10
+
+ Returns:
+ 对比分析结果字典
+ """
try:
# 参数验证
platforms = validate_platforms(platforms)
@@ -1932,6 +2404,7 @@ return {"success": False, "error": {"code": "INTERNAL_ERROR", "message": str(e)}}
def _parse_period(self, period: Union[Dict[str, str], str]) -> Optional[tuple]:
+ """解析时间段为日期范围元组"""
today = datetime.now()
if isinstance(period, str):
@@ -1969,6 +2442,7 @@ platforms: Optional[List[str]],
topic: Optional[str]
) -> Dict:
+ """收集指定时期的新闻数据"""
start_date, end_date = date_range
all_news = []
all_keywords = Counter()
@@ -2029,6 +2503,7 @@ range2: tuple,
top_n: int
) -> Dict:
+ """总体概览对比"""
# 计算变化
count_change = data2["news_count"] - data1["news_count"]
count_change_pct = (count_change / data1["news_count"] * 100) if data1["news_count"] > 0 else 0
@@ -2071,6 +2546,7 @@ range2: tuple,
top_n: int
) -> Dict:
+ """话题变化分析"""
kw1 = data1["keywords"]
kw2 = data2["keywords"]
@@ -2122,6 +2598,7 @@ range1: tuple,
range2: tuple
) -> Dict:
+ """平台活跃度对比"""
ps1 = data1["platform_stats"]
ps2 = data2["platform_stats"]
@@ -2159,4 +2636,4 @@ "period1": sum(ps1.values()),
"period2": sum(ps2.values())
}
- }+ }
| https://raw.githubusercontent.com/sansan0/TrendRadar/HEAD/mcp_server/tools/analytics.py |
Write documentation strings for class attributes |
from langchain_core.messages import HumanMessage
from pydantic import BaseModel, Field
from src.data.models import CompanyNews
import pandas as pd
import numpy as np
import json
from src.graph.state import AgentState, show_agent_reasoning
from src.tools.api import get_company_news
from src.utils.api_key import get_api_key_from_state
from src.utils.llm import call_llm
from src.utils.progress import progress
from typing_extensions import Literal
class Sentiment(BaseModel):
sentiment: Literal["positive", "negative", "neutral"]
confidence: int = Field(description="Confidence 0-100")
def news_sentiment_agent(state: AgentState, agent_id: str = "news_sentiment_agent"):
data = state.get("data", {})
end_date = data.get("end_date")
tickers = data.get("tickers")
api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
sentiment_analysis = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Fetching company news")
company_news = get_company_news(
ticker=ticker,
end_date=end_date,
limit=100,
api_key=api_key,
)
news_signals = []
sentiment_confidences = {} # Store confidence scores for each article
if company_news:
# Check the 10 most recent articles
recent_articles = company_news[:10]
articles_without_sentiment = [news for news in recent_articles if news.sentiment is None]
# Analyze only the 5 most recent articles without sentiment to reduce LLM calls
sentiments_classified_by_llm = 0
if articles_without_sentiment:
# We only take the first 5 articles, but this is configurable
num_articles_to_analyze = 5
articles_to_analyze = articles_without_sentiment[:num_articles_to_analyze]
progress.update_status(agent_id, ticker, f"Analyzing sentiment for {len(articles_to_analyze)} articles")
for idx, news in enumerate(articles_to_analyze):
# We analyze based on title, but can also pass in the entire article text,
# but this is more expensive and requires extracting the text from the article.
# Note: this is an opportunity for improvement!
progress.update_status(agent_id, ticker, f"Analyzing sentiment for article {idx + 1} of {len(articles_to_analyze)}")
prompt = (
f"Please analyze the sentiment of the following news headline "
f"with the following context: "
f"The stock is {ticker}. "
f"Determine if sentiment is 'positive', 'negative', or 'neutral' for the stock {ticker} only. "
f"Also provide a confidence score for your prediction from 0 to 100. "
f"Respond in JSON format.\n\n"
f"Headline: {news.title}"
)
response = call_llm(prompt, Sentiment, agent_name=agent_id, state=state)
if response:
news.sentiment = response.sentiment.lower()
sentiment_confidences[id(news)] = response.confidence
else:
news.sentiment = "neutral"
sentiment_confidences[id(news)] = 0
sentiments_classified_by_llm += 1
# Aggregate sentiment across all articles
sentiment = pd.Series([n.sentiment for n in company_news]).dropna()
news_signals = np.where(sentiment == "negative","bearish", np.where(sentiment == "positive", "bullish", "neutral")).tolist()
progress.update_status(agent_id, ticker, "Aggregating signals")
# Calculate the sentiment signals
bullish_signals = news_signals.count("bullish")
bearish_signals = news_signals.count("bearish")
neutral_signals = news_signals.count("neutral")
if bullish_signals > bearish_signals:
overall_signal = "bullish"
elif bearish_signals > bullish_signals:
overall_signal = "bearish"
else:
overall_signal = "neutral"
total_signals = len(news_signals)
confidence = _calculate_confidence_score(
sentiment_confidences=sentiment_confidences,
company_news=company_news,
overall_signal=overall_signal,
bullish_signals=bullish_signals,
bearish_signals=bearish_signals,
total_signals=total_signals
)
# Create reasoning for the news sentiment
reasoning = {
"news_sentiment": {
"signal": overall_signal,
"confidence": confidence,
"metrics": {
"total_articles": total_signals,
"bullish_articles": bullish_signals,
"bearish_articles": bearish_signals,
"neutral_articles": neutral_signals,
"articles_classified_by_llm": sentiments_classified_by_llm,
},
}
}
# Create the sentiment analysis
sentiment_analysis[ticker] = {
"signal": overall_signal,
"confidence": confidence,
"reasoning": reasoning,
}
progress.update_status(agent_id, ticker, "Done", analysis=json.dumps(reasoning, indent=4))
message = HumanMessage(
content=json.dumps(sentiment_analysis),
name=agent_id,
)
if state.get("metadata", {}).get("show_reasoning"):
show_agent_reasoning(sentiment_analysis, "News Sentiment Analysis Agent")
if "analyst_signals" not in state["data"]:
state["data"]["analyst_signals"] = {}
state["data"]["analyst_signals"][agent_id] = sentiment_analysis
progress.update_status(agent_id, None, "Done")
return {
"messages": [message],
"data": state["data"],
}
def _calculate_confidence_score(
sentiment_confidences: dict,
company_news: list,
overall_signal: str,
bullish_signals: int,
bearish_signals: int,
total_signals: int
) -> float:
if total_signals == 0:
return 0.0
# Calculate weighted confidence using LLM confidence scores when available
if sentiment_confidences:
# Get articles that match the overall signal
matching_articles = [
news for news in company_news
if news.sentiment and (
(overall_signal == "bullish" and news.sentiment == "positive") or
(overall_signal == "bearish" and news.sentiment == "negative") or
(overall_signal == "neutral" and news.sentiment == "neutral")
)
]
# Calculate average confidence from LLM-classified articles that match the signal
llm_confidences = [
sentiment_confidences[id(news)]
for news in matching_articles
if id(news) in sentiment_confidences
]
if llm_confidences:
# Weight: 70% from LLM confidence scores, 30% from signal proportion
avg_llm_confidence = sum(llm_confidences) / len(llm_confidences)
signal_proportion = (max(bullish_signals, bearish_signals) / total_signals) * 100
return round(0.7 * avg_llm_confidence + 0.3 * signal_proportion, 2)
# Fallback to proportion-based confidence
return round((max(bullish_signals, bearish_signals) / total_signals) * 100, 2) | --- +++ @@ -16,12 +16,27 @@
class Sentiment(BaseModel):
+ """Represents the sentiment of a news article."""
sentiment: Literal["positive", "negative", "neutral"]
confidence: int = Field(description="Confidence 0-100")
def news_sentiment_agent(state: AgentState, agent_id: str = "news_sentiment_agent"):
+ """
+ Analyzes news sentiment for a list of tickers and generates trading signals.
+
+ This agent fetches company news, uses an LLM to classify the sentiment of articles
+ with missing sentiment data, and then aggregates the sentiments to produce an
+ overall signal (bullish, bearish, or neutral) and a confidence score for each ticker.
+
+ Args:
+ state: The current state of the agent graph.
+ agent_id: The ID of the agent.
+
+ Returns:
+ A dictionary containing the updated state with the agent's analysis.
+ """
data = state.get("data", {})
end_date = data.get("end_date")
tickers = data.get("tickers")
@@ -156,6 +171,23 @@ bearish_signals: int,
total_signals: int
) -> float:
+ """
+ Calculate confidence score for a sentiment signal.
+
+ Uses a weighted approach combining LLM confidence scores (70%) with
+ signal proportion (30%) when LLM classifications are available.
+
+ Args:
+ sentiment_confidences: Dictionary mapping news article IDs to confidence scores.
+ company_news: List of CompanyNews objects.
+ overall_signal: The overall sentiment signal ("bullish", "bearish", or "neutral").
+ bullish_signals: Count of bullish signals.
+ bearish_signals: Count of bearish signals.
+ total_signals: Total number of signals.
+
+ Returns:
+ Confidence score as a float between 0 and 100.
+ """
if total_signals == 0:
return 0.0
@@ -185,4 +217,4 @@ return round(0.7 * avg_llm_confidence + 0.3 * signal_proportion, 2)
# Fallback to proportion-based confidence
- return round((max(bullish_signals, bearish_signals) / total_signals) * 100, 2)+ return round((max(bullish_signals, bearish_signals) / total_signals) * 100, 2)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/news_sentiment.py |
Add detailed docstrings explaining each function | import json
import time
from langchain_core.messages import HumanMessage
from langchain_core.prompts import ChatPromptTemplate
from src.graph.state import AgentState, show_agent_reasoning
from pydantic import BaseModel, Field
from typing_extensions import Literal
from src.utils.progress import progress
from src.utils.llm import call_llm
class PortfolioDecision(BaseModel):
action: Literal["buy", "sell", "short", "cover", "hold"]
quantity: int = Field(description="Number of shares to trade")
confidence: int = Field(description="Confidence 0-100")
reasoning: str = Field(description="Reasoning for the decision")
class PortfolioManagerOutput(BaseModel):
decisions: dict[str, PortfolioDecision] = Field(description="Dictionary of ticker to trading decisions")
##### Portfolio Management Agent #####
def portfolio_management_agent(state: AgentState, agent_id: str = "portfolio_manager"):
portfolio = state["data"]["portfolio"]
analyst_signals = state["data"]["analyst_signals"]
tickers = state["data"]["tickers"]
position_limits = {}
current_prices = {}
max_shares = {}
signals_by_ticker = {}
for ticker in tickers:
progress.update_status(agent_id, ticker, "Processing analyst signals")
# Find the corresponding risk manager for this portfolio manager
if agent_id.startswith("portfolio_manager_"):
suffix = agent_id.split('_')[-1]
risk_manager_id = f"risk_management_agent_{suffix}"
else:
risk_manager_id = "risk_management_agent" # Fallback for CLI
risk_data = analyst_signals.get(risk_manager_id, {}).get(ticker, {})
position_limits[ticker] = risk_data.get("remaining_position_limit", 0.0)
current_prices[ticker] = float(risk_data.get("current_price", 0.0))
# Calculate maximum shares allowed based on position limit and price
if current_prices[ticker] > 0:
max_shares[ticker] = int(position_limits[ticker] // current_prices[ticker])
else:
max_shares[ticker] = 0
# Compress analyst signals to {sig, conf}
ticker_signals = {}
for agent, signals in analyst_signals.items():
if not agent.startswith("risk_management_agent") and ticker in signals:
sig = signals[ticker].get("signal")
conf = signals[ticker].get("confidence")
if sig is not None and conf is not None:
ticker_signals[agent] = {"sig": sig, "conf": conf}
signals_by_ticker[ticker] = ticker_signals
state["data"]["current_prices"] = current_prices
progress.update_status(agent_id, None, "Generating trading decisions")
result = generate_trading_decision(
tickers=tickers,
signals_by_ticker=signals_by_ticker,
current_prices=current_prices,
max_shares=max_shares,
portfolio=portfolio,
agent_id=agent_id,
state=state,
)
message = HumanMessage(
content=json.dumps({ticker: decision.model_dump() for ticker, decision in result.decisions.items()}),
name=agent_id,
)
if state["metadata"]["show_reasoning"]:
show_agent_reasoning({ticker: decision.model_dump() for ticker, decision in result.decisions.items()},
"Portfolio Manager")
progress.update_status(agent_id, None, "Done")
return {
"messages": state["messages"] + [message],
"data": state["data"],
}
def compute_allowed_actions(
tickers: list[str],
current_prices: dict[str, float],
max_shares: dict[str, int],
portfolio: dict[str, float],
) -> dict[str, dict[str, int]]:
allowed = {}
cash = float(portfolio.get("cash", 0.0))
positions = portfolio.get("positions", {}) or {}
margin_requirement = float(portfolio.get("margin_requirement", 0.5))
margin_used = float(portfolio.get("margin_used", 0.0))
equity = float(portfolio.get("equity", cash))
for ticker in tickers:
price = float(current_prices.get(ticker, 0.0))
pos = positions.get(
ticker,
{"long": 0, "long_cost_basis": 0.0, "short": 0, "short_cost_basis": 0.0},
)
long_shares = int(pos.get("long", 0) or 0)
short_shares = int(pos.get("short", 0) or 0)
max_qty = int(max_shares.get(ticker, 0) or 0)
# Start with zeros
actions = {"buy": 0, "sell": 0, "short": 0, "cover": 0, "hold": 0}
# Long side
if long_shares > 0:
actions["sell"] = long_shares
if cash > 0 and price > 0:
max_buy_cash = int(cash // price)
max_buy = max(0, min(max_qty, max_buy_cash))
if max_buy > 0:
actions["buy"] = max_buy
# Short side
if short_shares > 0:
actions["cover"] = short_shares
if price > 0 and max_qty > 0:
if margin_requirement <= 0.0:
# If margin requirement is zero or unset, only cap by max_qty
max_short = max_qty
else:
available_margin = max(0.0, (equity / margin_requirement) - margin_used)
max_short_margin = int(available_margin // price)
max_short = max(0, min(max_qty, max_short_margin))
if max_short > 0:
actions["short"] = max_short
# Hold always valid
actions["hold"] = 0
# Prune zero-capacity actions to reduce tokens, keep hold
pruned = {"hold": 0}
for k, v in actions.items():
if k != "hold" and v > 0:
pruned[k] = v
allowed[ticker] = pruned
return allowed
def _compact_signals(signals_by_ticker: dict[str, dict]) -> dict[str, dict]:
out = {}
for t, agents in signals_by_ticker.items():
if not agents:
out[t] = {}
continue
compact = {}
for agent, payload in agents.items():
sig = payload.get("sig") or payload.get("signal")
conf = payload.get("conf") if "conf" in payload else payload.get("confidence")
if sig is not None and conf is not None:
compact[agent] = {"sig": sig, "conf": conf}
out[t] = compact
return out
def generate_trading_decision(
tickers: list[str],
signals_by_ticker: dict[str, dict],
current_prices: dict[str, float],
max_shares: dict[str, int],
portfolio: dict[str, float],
agent_id: str,
state: AgentState,
) -> PortfolioManagerOutput:
# Deterministic constraints
allowed_actions_full = compute_allowed_actions(tickers, current_prices, max_shares, portfolio)
# Pre-fill pure holds to avoid sending them to the LLM at all
prefilled_decisions: dict[str, PortfolioDecision] = {}
tickers_for_llm: list[str] = []
for t in tickers:
aa = allowed_actions_full.get(t, {"hold": 0})
# If only 'hold' key exists, there is no trade possible
if set(aa.keys()) == {"hold"}:
prefilled_decisions[t] = PortfolioDecision(
action="hold", quantity=0, confidence=100.0, reasoning="No valid trade available"
)
else:
tickers_for_llm.append(t)
if not tickers_for_llm:
return PortfolioManagerOutput(decisions=prefilled_decisions)
# Build compact payloads only for tickers sent to LLM
compact_signals = _compact_signals({t: signals_by_ticker.get(t, {}) for t in tickers_for_llm})
compact_allowed = {t: allowed_actions_full[t] for t in tickers_for_llm}
# Minimal prompt template
template = ChatPromptTemplate.from_messages(
[
(
"system",
"You are a portfolio manager.\n"
"Inputs per ticker: analyst signals and allowed actions with max qty (already validated).\n"
"Pick one allowed action per ticker and a quantity ≤ the max. "
"Keep reasoning very concise (max 100 chars). No cash or margin math. Return JSON only."
),
(
"human",
"Signals:\n{signals}\n\n"
"Allowed:\n{allowed}\n\n"
"Format:\n"
"{{\n"
' "decisions": {{\n'
' "TICKER": {{"action":"...","quantity":int,"confidence":int,"reasoning":"..."}}\n'
" }}\n"
"}}"
),
]
)
prompt_data = {
"signals": json.dumps(compact_signals, separators=(",", ":"), ensure_ascii=False),
"allowed": json.dumps(compact_allowed, separators=(",", ":"), ensure_ascii=False),
}
prompt = template.invoke(prompt_data)
# Default factory fills remaining tickers as hold if the LLM fails
def create_default_portfolio_output():
# start from prefilled
decisions = dict(prefilled_decisions)
for t in tickers_for_llm:
decisions[t] = PortfolioDecision(
action="hold", quantity=0, confidence=0.0, reasoning="Default decision: hold"
)
return PortfolioManagerOutput(decisions=decisions)
llm_out = call_llm(
prompt=prompt,
pydantic_model=PortfolioManagerOutput,
agent_name=agent_id,
state=state,
default_factory=create_default_portfolio_output,
)
# Merge prefilled holds with LLM results
merged = dict(prefilled_decisions)
merged.update(llm_out.decisions)
return PortfolioManagerOutput(decisions=merged) | --- +++ @@ -23,6 +23,7 @@
##### Portfolio Management Agent #####
def portfolio_management_agent(state: AgentState, agent_id: str = "portfolio_manager"):
+ """Makes final trading decisions and generates orders for multiple tickers"""
portfolio = state["data"]["portfolio"]
analyst_signals = state["data"]["analyst_signals"]
@@ -98,6 +99,7 @@ max_shares: dict[str, int],
portfolio: dict[str, float],
) -> dict[str, dict[str, int]]:
+ """Compute allowed actions and max quantities for each ticker deterministically."""
allowed = {}
cash = float(portfolio.get("cash", 0.0))
positions = portfolio.get("positions", {}) or {}
@@ -156,6 +158,7 @@
def _compact_signals(signals_by_ticker: dict[str, dict]) -> dict[str, dict]:
+ """Keep only {agent: {sig, conf}} and drop empty agents."""
out = {}
for t, agents in signals_by_ticker.items():
if not agents:
@@ -180,6 +183,7 @@ agent_id: str,
state: AgentState,
) -> PortfolioManagerOutput:
+ """Get decisions from the LLM with deterministic constraints and a minimal prompt."""
# Deterministic constraints
allowed_actions_full = compute_allowed_actions(tickers, current_prices, max_shares, portfolio)
@@ -255,4 +259,4 @@ # Merge prefilled holds with LLM results
merged = dict(prefilled_decisions)
merged.update(llm_out.decisions)
- return PortfolioManagerOutput(decisions=merged)+ return PortfolioManagerOutput(decisions=merged)
| https://raw.githubusercontent.com/virattt/ai-hedge-fund/HEAD/src/agents/portfolio_manager.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.