my-project-public

repository

loading code, commits, and activity

repositories

loading repo index

#1	import importlib
#2	from typing import Dict, Optional, Union
#3
#4	from mem0.configs.embeddings.base import BaseEmbedderConfig
#5	from mem0.configs.llms.anthropic import AnthropicConfig
#6	from mem0.configs.llms.azure import AzureOpenAIConfig
#7	from mem0.configs.llms.base import BaseLlmConfig
#8	from mem0.configs.llms.deepseek import DeepSeekConfig
#9	from mem0.configs.llms.lmstudio import LMStudioConfig
#10	from mem0.configs.llms.ollama import OllamaConfig
#11	from mem0.configs.llms.openai import OpenAIConfig
#12	from mem0.configs.llms.vllm import VllmConfig
#13	from mem0.configs.rerankers.base import BaseRerankerConfig
#14	from mem0.configs.rerankers.cohere import CohereRerankerConfig
#15	from mem0.configs.rerankers.sentence_transformer import SentenceTransformerRerankerConfig
#16	from mem0.configs.rerankers.zero_entropy import ZeroEntropyRerankerConfig
#17	from mem0.configs.rerankers.llm import LLMRerankerConfig
#18	from mem0.configs.rerankers.huggingface import HuggingFaceRerankerConfig
#19	from mem0.embeddings.mock import MockEmbeddings
#20
#21
#22	def load_class(class_type):
#23	module_path, class_name = class_type.rsplit(".", 1)
#24	module = importlib.import_module(module_path)
#25	return getattr(module, class_name)
#26
#27
#28	class LlmFactory:
#29	"""
#30	Factory for creating LLM instances with appropriate configurations.
#31	Supports both old-style BaseLlmConfig and new provider-specific configs.
#32	"""
#33
#34	# Provider mappings with their config classes
#35	provider_to_class = {
#36	"ollama": ("mem0.llms.ollama.OllamaLLM", OllamaConfig),
#37	"openai": ("mem0.llms.openai.OpenAILLM", OpenAIConfig),
#38	"groq": ("mem0.llms.groq.GroqLLM", BaseLlmConfig),
#39	"together": ("mem0.llms.together.TogetherLLM", BaseLlmConfig),
#40	"aws_bedrock": ("mem0.llms.aws_bedrock.AWSBedrockLLM", BaseLlmConfig),
#41	"litellm": ("mem0.llms.litellm.LiteLLM", BaseLlmConfig),
#42	"azure_openai": ("mem0.llms.azure_openai.AzureOpenAILLM", AzureOpenAIConfig),
#43	"openai_structured": ("mem0.llms.openai_structured.OpenAIStructuredLLM", OpenAIConfig),
#44	"anthropic": ("mem0.llms.anthropic.AnthropicLLM", AnthropicConfig),
#45	"azure_openai_structured": ("mem0.llms.azure_openai_structured.AzureOpenAIStructuredLLM", AzureOpenAIConfig),
#46	"gemini": ("mem0.llms.gemini.GeminiLLM", BaseLlmConfig),
#47	"deepseek": ("mem0.llms.deepseek.DeepSeekLLM", DeepSeekConfig),
#48	"xai": ("mem0.llms.xai.XAILLM", BaseLlmConfig),
#49	"sarvam": ("mem0.llms.sarvam.SarvamLLM", BaseLlmConfig),
#50	"lmstudio": ("mem0.llms.lmstudio.LMStudioLLM", LMStudioConfig),
#51	"vllm": ("mem0.llms.vllm.VllmLLM", VllmConfig),
#52	"langchain": ("mem0.llms.langchain.LangchainLLM", BaseLlmConfig),
#53	}
#54
#55	@classmethod
#56	def create(cls, provider_name: str, config: Optional[Union[BaseLlmConfig, Dict]] = None, **kwargs):
#57	"""
#58	Create an LLM instance with the appropriate configuration.
#59
#60	Args:
#61	provider_name (str): The provider name (e.g., 'openai', 'anthropic')
#62	config: Configuration object or dict. If None, will create default config
#63	**kwargs: Additional configuration parameters
#64
#65	Returns:
#66	Configured LLM instance
#67
#68	Raises:
#69	ValueError: If provider is not supported
#70	"""
#71	if provider_name not in cls.provider_to_class:
#72	raise ValueError(f"Unsupported Llm provider: {provider_name}")
#73
#74	class_type, config_class = cls.provider_to_class[provider_name]
#75	llm_class = load_class(class_type)
#76
#77	# Handle configuration
#78	if config is None:
#79	# Create default config with kwargs
#80	config = config_class(**kwargs)
#81	elif isinstance(config, dict):
#82	# Merge dict config with kwargs
#83	config.update(kwargs)
#84	config = config_class(**config)
#85	elif isinstance(config, BaseLlmConfig):
#86	# Convert base config to provider-specific config if needed
#87	if config_class != BaseLlmConfig:
#88	# Convert to provider-specific config
#89	config_dict = {
#90	"model": config.model,
#91	"temperature": config.temperature,
#92	"api_key": config.api_key,
#93	"max_tokens": config.max_tokens,
#94	"top_p": config.top_p,
#95	"top_k": config.top_k,
#96	"enable_vision": config.enable_vision,
#97	"vision_details": config.vision_details,
#98	"http_client_proxies": config.http_client,
#99	}
#100	config_dict.update(kwargs)
#101	config = config_class(**config_dict)
#102	else:
#103	# Use base config as-is
#104	pass
#105	else:
#106	# Assume it's already the correct config type
#107	pass
#108
#109	return llm_class(config)
#110
#111	@classmethod
#112	def register_provider(cls, name: str, class_path: str, config_class=None):
#113	"""
#114	Register a new provider.
#115
#116	Args:
#117	name (str): Provider name
#118	class_path (str): Full path to LLM class
#119	config_class: Configuration class for the provider (defaults to BaseLlmConfig)
#120	"""
#121	if config_class is None:
#122	config_class = BaseLlmConfig
#123	cls.provider_to_class[name] = (class_path, config_class)
#124
#125	@classmethod
#126	def get_supported_providers(cls) -> list:
#127	"""
#128	Get list of supported providers.
#129
#130	Returns:
#131	list: List of supported provider names
#132	"""
#133	return list(cls.provider_to_class.keys())
#134
#135
#136	class EmbedderFactory:
#137	provider_to_class = {
#138	"openai": "mem0.embeddings.openai.OpenAIEmbedding",
#139	"ollama": "mem0.embeddings.ollama.OllamaEmbedding",
#140	"huggingface": "mem0.embeddings.huggingface.HuggingFaceEmbedding",
#141	"azure_openai": "mem0.embeddings.azure_openai.AzureOpenAIEmbedding",
#142	"gemini": "mem0.embeddings.gemini.GoogleGenAIEmbedding",
#143	"vertexai": "mem0.embeddings.vertexai.VertexAIEmbedding",
#144	"together": "mem0.embeddings.together.TogetherEmbedding",
#145	"lmstudio": "mem0.embeddings.lmstudio.LMStudioEmbedding",
#146	"langchain": "mem0.embeddings.langchain.LangchainEmbedding",
#147	"aws_bedrock": "mem0.embeddings.aws_bedrock.AWSBedrockEmbedding",
#148	"fastembed": "mem0.embeddings.fastembed.FastEmbedEmbedding",
#149	}
#150
#151	@classmethod
#152	def create(cls, provider_name, config, vector_config: Optional[dict]):
#153	if provider_name == "upstash_vector" and vector_config and vector_config.enable_embeddings:
#154	return MockEmbeddings()
#155	class_type = cls.provider_to_class.get(provider_name)
#156	if class_type:
#157	embedder_instance = load_class(class_type)
#158	base_config = BaseEmbedderConfig(**config)
#159	return embedder_instance(base_config)
#160	else:
#161	raise ValueError(f"Unsupported Embedder provider: {provider_name}")
#162
#163
#164	class VectorStoreFactory:
#165	provider_to_class = {
#166	"qdrant": "mem0.vector_stores.qdrant.Qdrant",
#167	"chroma": "mem0.vector_stores.chroma.ChromaDB",
#168	"pgvector": "mem0.vector_stores.pgvector.PGVector",
#169	"milvus": "mem0.vector_stores.milvus.MilvusDB",
#170	"upstash_vector": "mem0.vector_stores.upstash_vector.UpstashVector",
#171	"azure_ai_search": "mem0.vector_stores.azure_ai_search.AzureAISearch",
#172	"azure_mysql": "mem0.vector_stores.azure_mysql.AzureMySQL",
#173	"pinecone": "mem0.vector_stores.pinecone.PineconeDB",
#174	"mongodb": "mem0.vector_stores.mongodb.MongoDB",
#175	"redis": "mem0.vector_stores.redis.RedisDB",
#176	"valkey": "mem0.vector_stores.valkey.ValkeyDB",
#177	"databricks": "mem0.vector_stores.databricks.Databricks",
#178	"elasticsearch": "mem0.vector_stores.elasticsearch.ElasticsearchDB",
#179	"vertex_ai_vector_search": "mem0.vector_stores.vertex_ai_vector_search.GoogleMatchingEngine",
#180	"opensearch": "mem0.vector_stores.opensearch.OpenSearchDB",
#181	"supabase": "mem0.vector_stores.supabase.Supabase",
#182	"weaviate": "mem0.vector_stores.weaviate.Weaviate",
#183	"faiss": "mem0.vector_stores.faiss.FAISS",
#184	"langchain": "mem0.vector_stores.langchain.Langchain",
#185	"s3_vectors": "mem0.vector_stores.s3_vectors.S3Vectors",
#186	"baidu": "mem0.vector_stores.baidu.BaiduDB",
#187	"cassandra": "mem0.vector_stores.cassandra.CassandraDB",
#188	"neptune": "mem0.vector_stores.neptune_analytics.NeptuneAnalyticsVector",
#189	}
#190
#191	@classmethod
#192	def create(cls, provider_name, config):
#193	class_type = cls.provider_to_class.get(provider_name)
#194	if class_type:
#195	if not isinstance(config, dict):
#196	config = config.model_dump()
#197	vector_store_instance = load_class(class_type)
#198	return vector_store_instance(**config)
#199	else:
#200	raise ValueError(f"Unsupported VectorStore provider: {provider_name}")
#201
#202	@classmethod
#203	def reset(cls, instance):
#204	instance.reset()
#205	return instance
#206
#207
#208	class GraphStoreFactory:
#209	"""
#210	Factory for creating MemoryGraph instances for different graph store providers.
#211	Usage: GraphStoreFactory.create(provider_name, config)
#212	"""
#213
#214	provider_to_class = {
#215	"memgraph": "mem0.memory.memgraph_memory.MemoryGraph",
#216	"neptune": "mem0.graphs.neptune.neptunegraph.MemoryGraph",
#217	"neptunedb": "mem0.graphs.neptune.neptunedb.MemoryGraph",
#218	"kuzu": "mem0.memory.kuzu_memory.MemoryGraph",
#219	"default": "mem0.memory.graph_memory.MemoryGraph",
#220	}
#221
#222	@classmethod
#223	def create(cls, provider_name, config):
#224	class_type = cls.provider_to_class.get(provider_name, cls.provider_to_class["default"])
#225	try:
#226	GraphClass = load_class(class_type)
#227	except (ImportError, AttributeError) as e:
#228	raise ImportError(f"Could not import MemoryGraph for provider '{provider_name}': {e}")
#229	return GraphClass(config)
#230
#231
#232	class RerankerFactory:
#233	"""
#234	Factory for creating reranker instances with appropriate configurations.
#235	Supports provider-specific configs following the same pattern as other factories.
#236	"""
#237
#238	# Provider mappings with their config classes
#239	provider_to_class = {
#240	"cohere": ("mem0.reranker.cohere_reranker.CohereReranker", CohereRerankerConfig),
#241	"sentence_transformer": ("mem0.reranker.sentence_transformer_reranker.SentenceTransformerReranker", SentenceTransformerRerankerConfig),
#242	"zero_entropy": ("mem0.reranker.zero_entropy_reranker.ZeroEntropyReranker", ZeroEntropyRerankerConfig),
#243	"llm_reranker": ("mem0.reranker.llm_reranker.LLMReranker", LLMRerankerConfig),
#244	"huggingface": ("mem0.reranker.huggingface_reranker.HuggingFaceReranker", HuggingFaceRerankerConfig),
#245	}
#246
#247	@classmethod
#248	def create(cls, provider_name: str, config: Optional[Union[BaseRerankerConfig, Dict]] = None, **kwargs):
#249	"""
#250	Create a reranker instance based on the provider and configuration.
#251
#252	Args:
#253	provider_name: The reranker provider (e.g., 'cohere', 'sentence_transformer')
#254	config: Configuration object or dictionary
#255	**kwargs: Additional configuration parameters
#256
#257	Returns:
#258	Reranker instance configured for the specified provider
#259
#260	Raises:
#261	ImportError: If the provider class cannot be imported
#262	ValueError: If the provider is not supported
#263	"""
#264	if provider_name not in cls.provider_to_class:
#265	raise ValueError(f"Unsupported reranker provider: {provider_name}")
#266
#267	class_path, config_class = cls.provider_to_class[provider_name]
#268
#269	# Handle configuration
#270	if config is None:
#271	config = config_class(**kwargs)
#272	elif isinstance(config, dict):
#273	config = config_class(config, kwargs)
#274	elif not isinstance(config, BaseRerankerConfig):
#275	raise ValueError(f"Config must be a {config_class.__name__} instance or dict")
#276
#277	# Import and create the reranker class
#278	try:
#279	reranker_class = load_class(class_path)
#280	except (ImportError, AttributeError) as e:
#281	raise ImportError(f"Could not import reranker for provider '{provider_name}': {e}")
#282
#283	return reranker_class(config)
#284

z6Mkq5mY3JWtxoxUobWcfNHm7AkRubgSWEZTkBVqZXJviFZ5/my-project-public