diff --git a/python/packages/redis/agent_framework_redis/_context_provider.py b/python/packages/redis/agent_framework_redis/_context_provider.py index e44ecbe489..c6de176470 100644 --- a/python/packages/redis/agent_framework_redis/_context_provider.py +++ b/python/packages/redis/agent_framework_redis/_context_provider.py @@ -374,7 +374,7 @@ async def _redis_search( vector_field_name=self.vector_field_name, text_scorer=text_scorer, filter_expression=combined_filter, - alpha=alpha, + linear_alpha=alpha, dtype=self.redis_vectorizer.dtype, num_results=num_results, return_fields=return_fields, diff --git a/python/samples/02-agents/context_providers/redis/azure_redis_conversation.py b/python/samples/02-agents/context_providers/redis/azure_redis_conversation.py index d5e3bd6f8e..71780067c4 100644 --- a/python/samples/02-agents/context_providers/redis/azure_redis_conversation.py +++ b/python/samples/02-agents/context_providers/redis/azure_redis_conversation.py @@ -86,35 +86,38 @@ async def main() -> None: context_providers=[history_provider], ) + # Use a fixed session ID so Redis history persists across separate program runs + session = agent.create_session(session_id="redis-demo-session") + # Conversation query = "Remember that I enjoy gumbo" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) # Ask the agent to recall the stored preference; it should retrieve from memory query = "What do I enjoy?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "What did I say to you just now?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "Remember that I have a meeting at 3pm tomorrow" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "Tulips are red" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "What was the first thing I said to you this conversation?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) diff --git a/python/samples/02-agents/context_providers/redis/redis_basics.py b/python/samples/02-agents/context_providers/redis/redis_basics.py index 079108bd15..997573180a 100644 --- a/python/samples/02-agents/context_providers/redis/redis_basics.py +++ b/python/samples/02-agents/context_providers/redis/redis_basics.py @@ -37,6 +37,10 @@ from redisvl.extensions.cache.embeddings import EmbeddingsCache from redisvl.utils.vectorize import OpenAITextVectorizer +# Default Redis URL for local Redis Stack (docker run -d -p 6379:6379 redis/redis-stack:latest). +# Override via the REDIS_URL environment variable for remote or authenticated instances. +REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379") + # NOTE: approval_mode="never_require" is for sample brevity. # Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py @@ -121,14 +125,14 @@ async def main() -> None: vectorizer = OpenAITextVectorizer( model="text-embedding-ada-002", api_config={"api_key": os.getenv("OPENAI_API_KEY")}, - cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url="redis://localhost:6379"), + cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL), ) # The provider manages persistence and retrieval. application_id/agent_id/user_id # scope data for multi-tenant separation; thread_id (set later) narrows to a # specific conversation. provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_basics", application_id="matrix_of_kermits", agent_id="agent_kermit", @@ -151,16 +155,14 @@ async def main() -> None: from agent_framework import AgentSession, SessionContext session = AgentSession(session_id="runA") - context = SessionContext() - context.extend_messages("input", messages) + context = SessionContext(input_messages=messages) state = session.state # Store messages via after_run await provider.after_run(agent=None, session=session, context=context, state=state) # Retrieve relevant memories via before_run - query_context = SessionContext() - query_context.extend_messages("input", [Message("system", ["B: Assistant Message"])]) + query_context = SessionContext(input_messages=[Message("system", ["B: Assistant Message"])]) await provider.before_run(agent=None, session=session, context=query_context, state=state) # Inspect retrieved memories that would be injected into instructions @@ -179,12 +181,12 @@ async def main() -> None: vectorizer = OpenAITextVectorizer( model="text-embedding-ada-002", api_config={"api_key": os.getenv("OPENAI_API_KEY")}, - cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url="redis://localhost:6379"), + cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL), ) # Recreate a clean index so the next scenario starts fresh provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_basics_2", prefix="context_2", application_id="matrix_of_kermits", @@ -211,14 +213,15 @@ async def main() -> None: ) # Teach a user preference; the agent writes this to the provider's memory + session = agent.create_session(session_id="basics-session-2") query = "Remember that I enjoy glugenflorgle" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) # Ask the agent to recall the stored preference; it should retrieve from memory query = "What do I enjoy?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) @@ -232,7 +235,7 @@ async def main() -> None: # Text-only provider (full-text search only). Omits vectorizer and related params. provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_basics_3", prefix="context_3", application_id="matrix_of_kermits", @@ -253,13 +256,14 @@ async def main() -> None: context_providers=[provider], ) # Invoke the tool; outputs become part of memory/context + session = agent.create_session(session_id="basics-session-3") query = "Are there any flights from new york city (jfk) to la? Give me details" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) # Verify the agent can recall tool-derived context query = "Which flight did I ask about?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) diff --git a/python/samples/02-agents/context_providers/redis/redis_conversation.py b/python/samples/02-agents/context_providers/redis/redis_conversation.py index f25dbbbe52..eb20061d5a 100644 --- a/python/samples/02-agents/context_providers/redis/redis_conversation.py +++ b/python/samples/02-agents/context_providers/redis/redis_conversation.py @@ -23,6 +23,10 @@ from redisvl.extensions.cache.embeddings import EmbeddingsCache from redisvl.utils.vectorize import OpenAITextVectorizer +# Default Redis URL for local Redis Stack (docker run -d -p 6379:6379 redis/redis-stack:latest). +# Override via the REDIS_URL environment variable for remote or authenticated instances. +REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379") + async def main() -> None: """Walk through provider and chat message store usage. @@ -34,12 +38,12 @@ async def main() -> None: vectorizer = OpenAITextVectorizer( model="text-embedding-ada-002", api_config={"api_key": os.getenv("OPENAI_API_KEY")}, - cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url="redis://localhost:6379"), + cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL), ) provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_conversation", prefix="redis_conversation", application_id="matrix_of_kermits", @@ -69,35 +73,38 @@ async def main() -> None: context_providers=[provider], ) + # Create a session so the provider can scope storage/retrieval to this conversation + session = agent.create_session(session_id="redis-conversation-session") + # Teach a user preference; the agent writes this to the provider's memory query = "Remember that I enjoy gumbo" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) # Ask the agent to recall the stored preference; it should retrieve from memory query = "What do I enjoy?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "What did I say to you just now?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) - query = "Remember that I have a meeting at 3pm tomorro" - result = await agent.run(query) + query = "Remember that I have a meeting at 3pm tomorrow" + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "Tulips are red" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) query = "What was the first thing I said to you this conversation?" - result = await agent.run(query) + result = await agent.run(query, session=session) print("User: ", query) print("Agent: ", result) # Drop / delete the provider index in Redis diff --git a/python/samples/02-agents/context_providers/redis/redis_sessions.py b/python/samples/02-agents/context_providers/redis/redis_sessions.py index aa1b7501f8..c2ef11f253 100644 --- a/python/samples/02-agents/context_providers/redis/redis_sessions.py +++ b/python/samples/02-agents/context_providers/redis/redis_sessions.py @@ -35,6 +35,10 @@ from redisvl.extensions.cache.embeddings import EmbeddingsCache from redisvl.utils.vectorize import OpenAITextVectorizer +# Default Redis URL for local Redis Stack (docker run -d -p 6379:6379 redis/redis-stack:latest). +# Override via the REDIS_URL environment variable for remote or authenticated instances. +REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379") + # Please set OPENAI_API_KEY to use the OpenAI vectorizer. # For chat responses, also set AZURE_AI_PROJECT_ENDPOINT and AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME. @@ -57,12 +61,11 @@ async def example_global_thread_scope() -> None: provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_threads_global", application_id="threads_demo_app", agent_id="threads_demo_agent", user_id="threads_demo_user", - scope_to_per_operation_thread_id=False, # Share memories across all sessions ) agent = client.as_agent( @@ -76,9 +79,10 @@ async def example_global_thread_scope() -> None: ) # Store a preference in the global scope + session = agent.create_session(session_id="global-scope-session") query = "Remember that I prefer technical responses with code examples when discussing programming." print(f"User: {query}") - result = await agent.run(query) + result = await agent.run(query, session=session) print(f"Agent: {result}\n") # Create a new session - memories should still be accessible due to global scope @@ -106,19 +110,18 @@ async def example_per_operation_thread_scope() -> None: vectorizer = OpenAITextVectorizer( model="text-embedding-ada-002", api_config={"api_key": os.getenv("OPENAI_API_KEY")}, - cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url="redis://localhost:6379"), + cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL), ) provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_threads_dynamic", # overwrite_redis_index=True, # drop_redis_index=True, application_id="threads_demo_app", agent_id="threads_demo_agent", user_id="threads_demo_user", - scope_to_per_operation_thread_id=True, # Isolate memories per session redis_vectorizer=vectorizer, vector_field_name="vector", vector_algorithm="hnsw", @@ -172,12 +175,12 @@ async def example_multiple_agents() -> None: vectorizer = OpenAITextVectorizer( model="text-embedding-ada-002", api_config={"api_key": os.getenv("OPENAI_API_KEY")}, - cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url="redis://localhost:6379"), + cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL), ) personal_provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_threads_agents", application_id="threads_demo_app", agent_id="agent_personal", @@ -196,7 +199,7 @@ async def example_multiple_agents() -> None: work_provider = RedisContextProvider( source_id="redis_context", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, index_name="redis_threads_agents", application_id="threads_demo_app", agent_id="agent_work", @@ -214,25 +217,27 @@ async def example_multiple_agents() -> None: ) # Store personal information + personal_session = personal_agent.create_session(session_id="personal-session") query = "Remember that I like to exercise at 6 AM and prefer outdoor activities." print(f"User to Personal Agent: {query}") - result = await personal_agent.run(query) + result = await personal_agent.run(query, session=personal_session) print(f"Personal Agent: {result}\n") # Store work information + work_session = work_agent.create_session(session_id="work-session") query = "Remember that I have team meetings every Tuesday at 2 PM." print(f"User to Work Agent: {query}") - result = await work_agent.run(query) + result = await work_agent.run(query, session=work_session) print(f"Work Agent: {result}\n") # Test memory isolation query = "What do you know about my schedule?" print(f"User to Personal Agent: {query}") - result = await personal_agent.run(query) + result = await personal_agent.run(query, session=personal_session) print(f"Personal Agent: {result}\n") print(f"User to Work Agent: {query}") - result = await work_agent.run(query) + result = await work_agent.run(query, session=work_session) print(f"Work Agent: {result}\n") # Clean up the Redis index (shared) diff --git a/python/samples/02-agents/conversations/redis_chat_message_store_session.py b/python/samples/02-agents/conversations/redis_chat_message_store_session.py index f54edd8170..7224f5ea9a 100644 --- a/python/samples/02-agents/conversations/redis_chat_message_store_session.py +++ b/python/samples/02-agents/conversations/redis_chat_message_store_session.py @@ -8,6 +8,10 @@ from agent_framework.openai import OpenAIChatClient from agent_framework.redis import RedisHistoryProvider +# Default Redis URL for local Redis Stack (docker run -d -p 6379:6379 redis/redis-stack:latest). +# Override via the REDIS_URL environment variable for remote or authenticated instances. +REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379") + """ Redis History Provider Session Example @@ -24,7 +28,7 @@ async def example_manual_memory_store() -> None: # Create Redis history provider redis_provider = RedisHistoryProvider( source_id="redis_basic_chat", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, ) # Create agent with Redis history provider @@ -62,7 +66,7 @@ async def example_user_session_management() -> None: # Create Redis history provider for specific user session redis_provider = RedisHistoryProvider( source_id=f"redis_{user_id}", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, max_messages=10, # Keep only last 10 messages ) @@ -103,7 +107,7 @@ async def example_conversation_persistence() -> None: print("--- Phase 1: Starting conversation ---") redis_provider = RedisHistoryProvider( source_id="redis_persistent_chat", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, ) agent = OpenAIChatClient().as_agent( @@ -152,7 +156,7 @@ async def example_session_serialization() -> None: redis_provider = RedisHistoryProvider( source_id="redis_serialization_chat", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, ) agent = OpenAIChatClient().as_agent( @@ -194,7 +198,7 @@ async def example_message_limits() -> None: # Create provider with small message limit redis_provider = RedisHistoryProvider( source_id="redis_limited_chat", - redis_url="redis://localhost:6379", + redis_url=REDIS_URL, max_messages=3, # Keep only 3 most recent messages ) @@ -229,7 +233,7 @@ async def main() -> None: print("Redis History Provider Examples") print("=" * 50) print("Prerequisites:") - print("- Redis server running on localhost:6379") + print(f"- Redis server running on {REDIS_URL}") print("- OPENAI_API_KEY environment variable set") print("=" * 50)