awesome-agent-skills
A curated collection of 1000+ agent skills from official dev teams and the community, compatible with Claude Code, Codex, Gemini CLI, Cursor, and more.
- 37k
- MIT
- 3 d ago
The maintainer has not written a description at the source.
Repo VoltAgent/voltagent-python, read from GitHub 1 min ago. VoltAgent has not joined Take My Repo.
VoltAgent/voltagent-python is a public repo on GitHub by VoltAgent. It declares the MIT license on GitHub. It is written mainly in Python, has 28 stars and last changed on 2025-06-05. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-18.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Modern, type-safe, and async-ready Python SDK for AI agent observability and tracing. Track your LLM workflows, agent interactions, and tool usage with comprehensive telemetry.
pip install voltagent
import asyncio from voltagent import VoltAgentSDK async def main(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key", auto_flush=True, flush_interval=5 ) # Start a trace (conversation/session) with automatic resource management async with sdk.trace( agentId="customer-support-v1", input={"query": "How to reset my password?"}, userId="user-123", conversationId="conv-456", tags=["support", "password-reset"] ) as trace: # Add an agent with automatic completion async with trace.add_agent({ "name": "Support Agent", "input": {"task": "Handle password reset request"}, "instructions": "You are a helpful customer support agent.", "metadata": { "model_parameters": {"model": "gpt-4"} } }) as agent: # Use a tool tool = await agent.add_tool({ "name": "knowledge-base-search", "input": {"query": "password reset procedure"} }) await tool.success( output={ "results": ["Reset via email", "Reset via SMS"], "relevance_score": 0.89 } ) # Complete the workflow - agent auto-completes when exiting context await agent.success( output={"response": "Password reset link sent!"}, usage={"prompt_tokens": 150, "completion_tokens": 85, "total_tokens": 235} ) # Trace auto-completes when exiting context asyncio.run(main())
import asyncio from voltagent import VoltAgentSDK, TraceStatus async def manual_example(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) trace = None agent = None try: # Manually create trace trace = await sdk.create_trace( agentId="customer-support-v1", input={"query": "How to reset my password?"}, userId="user-123", conversationId="conv-456", tags=["support", "password-reset"] ) # Manually add agent agent = await trace.add_agent({ "name": "Support Agent", "input": {"task": "Handle password reset request"}, "instructions": "You are a helpful customer support agent.", "metadata": { "model_parameters": {"model": "gpt-4"} } }) # Use a tool tool = await agent.add_tool({ "name": "knowledge-base-search", "input": {"query": "password reset procedure"} }) await tool.success( output={ "results": ["Reset via email", "Reset via SMS"], "relevance_score": 0.89 } ) # Manually complete agent await agent.success( output={"response": "Password reset link sent!"}, usage={"prompt_tokens": 150, "completion_tokens": 85, "total_tokens": 235} ) # Manually end trace await trace.end( output={"support_completed": True}, status=TraceStatus.COMPLETED ) except Exception as e: # Manual error handling if agent: await agent.error(status_message=f"Agent failed: {e}") if trace: await trace.end(status=TraceStatus.ERROR, metadata={"error": str(e)}) finally: await sdk.shutdown() asyncio.run(manual_example())
Best for:
Example scenarios:
Best for:
Example scenarios:
Trace
βββ Agent 1
β βββ Tool 1 β success/error
β βββ Memory 1 β success/error
β βββ Sub-Agent 1.1
β β βββ Tool 1.1.1 β success/error
β βββ Agent 1 β success/error
βββ Agent 2
βββ Retriever 1 β success/error
Set these environment variables for easy configuration:
export VOLTAGENT_BASE_URL="https://api.voltagent.dev" export VOLTAGENT_PUBLIC_KEY="your-public-key" export VOLTAGENT_SECRET_KEY="your-secret-key"
from voltagent import VoltAgentSDK sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key", auto_flush=True, flush_interval=5, timeout=30 )
Prerequisites: Create an account at https://console.voltagent.dev/ and set up an organization and project to get your API keys.
A trace represents one complete agent execution session. Every agent operation must happen within a trace.
async with sdk.trace( agentId="customer-support-v1", input={"query": "How to reset password?"}, userId="user-123", conversationId="conv-456", tags=["support", "password-reset"], metadata={ "priority": "high", "source": "web-chat" } ) as trace: # Your agent operations here pass
async with trace.add_agent({ "name": "Support Agent", "input": {"query": "User needs password reset help"}, "instructions": "You are a customer support agent specialized in helping users with account issues.", "metadata": { "model_parameters": { "model": "gpt-4", "temperature": 0.7, "max_tokens": 1000 }, "role": "customer-support", "specialization": "account-issues" } }) as agent: # Agent operations here pass
search_tool = await agent.add_tool({ "name": "knowledge-base-search", "input": { "query": "password reset procedure", "max_results": 5 }, "metadata": { "search_type": "semantic", "database": "support-kb" } }) # Tool success await search_tool.success( output={ "results": ["Reset via email", "Reset via SMS", "Contact support"], "count": 3, "relevance_score": 0.89 }, metadata={ "search_time": "0.2s", "index_used": "support-kb-v2" } ) # Tool error (if needed) await search_tool.error( status_message=Exception("Database connection timeout"), metadata={ "database": "support-kb", "timeout_ms": 5000 } )
memory_op = await agent.add_memory({ "name": "user-context-storage", "input": { "key": "user_123_context", "value": { "last_login": "2024-01-15", "account_type": "premium" }, "ttl": 3600 }, "metadata": { "type": "redis", "region": "us-east-1" } }) await memory_op.success( output={ "stored": True, "key": "user_123_context", "expires_at": "2024-01-15T15:00:00Z" }, metadata={ "cache_hit": False, "storage_latency": "2ms" } )
retriever = await agent.add_retriever({ "name": "policy-document-retriever", "input": { "query": "password reset policy for premium users", "max_documents": 3, "threshold": 0.8 }, "metadata": { "vector_store": "pinecone", "embedding_model": "text-embedding-ada-002" } }) await retriever.success( output={ "documents": [ "Premium users can reset passwords instantly via email", "Password reset requires 2FA verification for premium accounts" ], "relevance_scores": [0.95, 0.88] }, metadata={ "search_time": "0.3s", "documents_scanned": 1500 } )
Create hierarchical agent structures for complex workflows:
# Create a sub-agent under the main agent async with agent.add_agent({ "name": "Policy Checker", "input": { "user_id": "user-123", "request_type": "password-reset" }, "instructions": "You verify customer requests against company policies.", "metadata": { "role": "policy-verification", "parent_agent": agent.id, "model_parameters": {"model": "gpt-4"} } }) as policy_checker: # Add a tool to the sub-agent verification_tool = await policy_checker.add_tool({ "name": "policy-verification", "input": {"user_id": "user-123", "action": "password-reset"} }) await verification_tool.success( output={"policy_compliant": True, "required_verification": "2fa-sms"} ) # Complete the sub-agent await policy_checker.success( output={ "policy_compliant": True, "approval_granted": True }, usage={ "prompt_tokens": 85, "completion_tokens": 45, "total_tokens": 130 }, metadata={ "policies_checked": ["password-policy", "premium-user-policy"], "compliance_score": 0.95 } )
# Complete the main agent await agent.success( output={ "response": "Password reset link sent to user's email", "action_taken": "email-reset-link", "user_satisfied": True }, usage={ "prompt_tokens": 150, "completion_tokens": 85, "total_tokens": 235 }, metadata={ "response_time": "2.1s", "confidence_score": 0.95 } ) # Trace automatically completes when exiting context manager
sdk = VoltAgentSDK( base_url: str, public_key: str, secret_key: str, auto_flush: bool = True, # Enable automatic event flushing flush_interval: int = 5, # Flush every 5 seconds timeout: int = 30, # Request timeout in seconds max_retries: int = 3, # Maximum retries for failed requests retry_delay: float = 1.0 # Delay between retries )
async with sdk.trace( agentId: str, # The main agent identifier input: Optional[Dict] = None, # Input data for the trace userId: Optional[str] = None, # User identifier conversationId: Optional[str] = None, # Conversation identifier metadata: Optional[Dict] = None, # Additional metadata tags: Optional[List[str]] = None # Tags for filtering ) as trace: # Your trace operations pass
# Update trace metadata await trace.update( status: Optional[str] = None, metadata: Optional[Dict] = None ) # End trace manually (usually not needed with context managers) await trace.end( output: Optional[Dict] = None, status: str = "completed", usage: Optional[Dict] = None, metadata: Optional[Dict] = None ) # Add agents to trace async with trace.add_agent({ "name": str, "input": Optional[Dict], "instructions": Optional[str], "metadata": Optional[Dict] }) as agent: pass
# Add sub-agents async with agent.add_agent(options) as sub_agent: pass # Add tools tool = await agent.add_tool({ "name": str, "input": Optional[Dict], "metadata": Optional[Dict] }) # Add memory operations memory = await agent.add_memory({ "name": str, "input": Optional[Dict], "metadata": Optional[Dict] }) # Add retrieval operations retriever = await agent.add_retriever({ "name": str, "input": Optional[Dict], "metadata": Optional[Dict] }) # Complete agent - Success await agent.success( output: Optional[Dict] = None, usage: Optional[Dict] = None, # {prompt_tokens, completion_tokens, total_tokens} metadata: Optional[Dict] = None ) # Complete agent - Error await agent.error( status_message: Union[str, Exception, Dict], metadata: Optional[Dict] = None )
# Success completion await tool.success( output: Optional[Dict] = None, metadata: Optional[Dict] = None ) await memory.success( output: Optional[Dict] = None, metadata: Optional[Dict] = None ) await retriever.success( output: Optional[Dict] = None, metadata: Optional[Dict] = None ) # Error handling await tool.error( status_message: Union[str, Exception, Dict], metadata: Optional[Dict] = None ) await memory.error( status_message: Union[str, Exception, Dict], metadata: Optional[Dict] = None ) await retriever.error( status_message: Union[str, Exception, Dict], metadata: Optional[Dict] = None )
import asyncio from voltagent import VoltAgentSDK async def weather_example(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) async with sdk.trace( agentId="weather-agent-v1", input={"query": "Weather in Istanbul?"}, tags=["weather", "query"] ) as trace: async with trace.add_agent({ "name": "Weather Agent", "instructions": "You provide accurate weather information.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) as agent: # Call weather API weather_tool = await agent.add_tool({ "name": "weather_api", "input": {"city": "Istanbul"} }) await weather_tool.success( output={ "temperature": 22, "condition": "sunny", "humidity": 65 } ) # Save to memory memory = await agent.add_memory({ "name": "cache_weather", "input": { "key": "istanbul_weather", "value": {"temp": 22, "condition": "sunny"} } }) await memory.success( output={"cached": True, "expires_in": 3600} ) await agent.success( output={"response": "It's 22Β°C and sunny in Istanbul!"}, usage={"prompt_tokens": 50, "completion_tokens": 25, "total_tokens": 75} ) asyncio.run(weather_example())
import asyncio from voltagent import VoltAgentSDK, TraceStatus async def manual_weather_example(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) trace = None agent = None try: # Manually create trace trace = await sdk.create_trace( agentId="weather-agent-manual", input={"query": "Weather in Istanbul?"}, tags=["weather", "manual"] ) # Manually add agent agent = await trace.add_agent({ "name": "Weather Agent Manual", "instructions": "You provide accurate weather information.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) # Call weather API weather_tool = await agent.add_tool({ "name": "weather_api", "input": {"city": "Istanbul"} }) await weather_tool.success( output={ "temperature": 22, "condition": "sunny", "humidity": 65 } ) # Save to memory memory = await agent.add_memory({ "name": "cache_weather", "input": { "key": "istanbul_weather", "value": {"temp": 22, "condition": "sunny"} } }) await memory.success( output={"cached": True, "expires_in": 3600} ) # Manually complete agent await agent.success( output={"response": "It's 22Β°C and sunny in Istanbul!"}, usage={"prompt_tokens": 50, "completion_tokens": 25, "total_tokens": 75} ) # Manually end trace await trace.end( output={"weather_provided": True, "city": "Istanbul"}, status=TraceStatus.COMPLETED ) except Exception as e: if agent: await agent.error(status_message=f"Weather agent failed: {e}") if trace: await trace.end(status=TraceStatus.ERROR, metadata={"error": str(e)}) finally: await sdk.shutdown() asyncio.run(manual_weather_example())
async def research_workflow(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) async with sdk.trace( agentId="research-orchestrator", input={"topic": "AI trends 2024"}, tags=["research", "ai-trends"] ) as trace: # Research agent async with trace.add_agent({ "name": "Research Agent", "instructions": "You research and gather information on given topics.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) as researcher: search = await researcher.add_retriever({ "name": "web_search", "input": {"query": "AI trends 2024", "max_results": 10} }) await search.success( output={ "documents": ["AI trend doc 1", "AI trend doc 2"], "relevance_scores": [0.9, 0.8], "total_results": 10 } ) await researcher.success( output={"research_complete": True, "documents_found": 10}, usage={"prompt_tokens": 200, "completion_tokens": 150, "total_tokens": 350} ) # Summary agent async with trace.add_agent({ "name": "Summary Agent", "instructions": "You create comprehensive summaries from research data.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) as summarizer: # Translation sub-agent async with summarizer.add_agent({ "name": "Translation Agent", "instructions": "You translate content to different languages.", "metadata": {"model_parameters": {"model": "gpt-3.5-turbo"}} }) as translator: translate_tool = await translator.add_tool({ "name": "translate_api", "input": {"text": "AI trends summary", "target_language": "tr"} }) await translate_tool.success( output={"translated_text": "AI eΔilimleri ΓΆzeti..."} ) await translator.success( output={"translation": "Turkish translation completed"}, usage={"prompt_tokens": 100, "completion_tokens": 80, "total_tokens": 180} ) await summarizer.success( output={"summary": "Comprehensive AI trends summary with translation"}, usage={"prompt_tokens": 300, "completion_tokens": 200, "total_tokens": 500} ) asyncio.run(research_workflow())
async def manual_research_workflow(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) trace = None researcher = None summarizer = None translator = None try: # Manually create trace trace = await sdk.create_trace( agentId="research-orchestrator-manual", input={"topic": "AI trends 2024"}, tags=["research", "ai-trends", "manual"] ) # Manually create research agent researcher = await trace.add_agent({ "name": "Research Agent Manual", "instructions": "You research and gather information on given topics.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) search = await researcher.add_retriever({ "name": "web_search", "input": {"query": "AI trends 2024", "max_results": 10} }) await search.success( output={ "documents": ["AI trend doc 1", "AI trend doc 2"], "relevance_scores": [0.9, 0.8], "total_results": 10 } ) # Manually complete research agent await researcher.success( output={"research_complete": True, "documents_found": 10}, usage={"prompt_tokens": 200, "completion_tokens": 150, "total_tokens": 350} ) # Manually create summary agent summarizer = await trace.add_agent({ "name": "Summary Agent Manual", "instructions": "You create comprehensive summaries from research data.", "metadata": {"model_parameters": {"model": "gpt-4"}} }) # Manually create translation sub-agent translator = await summarizer.add_agent({ "name": "Translation Agent Manual", "instructions": "You translate content to different languages.", "metadata": {"model_parameters": {"model": "gpt-3.5-turbo"}} }) translate_tool = await translator.add_tool({ "name": "translate_api", "input": {"text": "AI trends summary", "target_language": "tr"} }) await translate_tool.success( output={"translated_text": "AI eΔilimleri ΓΆzeti..."} ) # Manually complete translation agent await translator.success( output={"translation": "Turkish translation completed"}, usage={"prompt_tokens": 100, "completion_tokens": 80, "total_tokens": 180} ) # Manually complete summary agent await summarizer.success( output={"summary": "Comprehensive AI trends summary with translation"}, usage={"prompt_tokens": 300, "completion_tokens": 200, "total_tokens": 500} ) # Manually end trace await trace.end( output={ "research_completed": True, "agents_used": 3, "total_documents": 10, "translation_completed": True }, status=TraceStatus.COMPLETED, usage={"prompt_tokens": 600, "completion_tokens": 430, "total_tokens": 1030} ) except Exception as e: # Manual cascade error handling if translator: await translator.error(status_message=f"Translation failed: {e}") if summarizer: await summarizer.error(status_message=f"Summary failed: {e}") if researcher: await researcher.error(status_message=f"Research failed: {e}") if trace: await trace.end(status=TraceStatus.ERROR, metadata={"error": str(e)}) finally: await sdk.shutdown() asyncio.run(manual_research_workflow())
async def error_handling_example(): sdk = VoltAgentSDK( base_url="https://api.voltagent.dev", public_key="your-public-key", secret_key="your-secret-key" ) async with sdk.trace( agentId="test-agent", input={"task": "risky operation"} ) as trace: async with trace.add_agent({ "name": "Risky Agent", "instructions": "You handle operations that might fail." }) as agent: risky_tool = await agent.add_tool({ "name": "external_api", "input": {"endpoint": "https://unreliable-api.com"} }) try: # Simulate API call that might fail result = await call_external_api() await risky_tool.success( output=result, metadata={"response_time": "1.2s"} ) await agent.success( output={"result": "Operation completed successfully"} ) except Exception as error: # Handle tool error await risky_tool.error( status_message=error, metadata={ "error_code": "API_TIMEOUT", "retry_attempts": 3 } ) # Handle agent error await agent.error( status_message="Agent failed due to tool error", metadata={ "failed_tool": "external_api", "error_type": "TIMEOUT" } ) asyncio.run(error_handling_example())
usage parameter for proper cost trackingawait sdk.shutdown() before your application exits to ensure all events are sentContext Manager Error Handling:
async with sdk.trace(agentId="error-prone") as trace: async with trace.add_agent({"name": "Worker"}) as agent: try: # Risky operation result = await risky_api_call() await tool.success(output=result) except Exception as e: # Handle specific tool errors await tool.error(status_message=e) # Context manager will handle agent/trace errors automatically
Manual Error Handling:
trace = None agent = None try: trace = await sdk.create_trace(agentId="error-prone") agent = await trace.add_agent({"name": "Worker"}) result = await risky_api_call() await agent.success(output=result) await trace.end(status=TraceStatus.COMPLETED) except Exception as e: # Cascade error handling if agent: await agent.error(status_message=f"Agent failed: {e}") if trace: await trace.end( status=TraceStatus.ERROR, metadata={"error": str(e), "error_type": type(e).__name__} ) finally: await sdk.shutdown()
# Install development dependencies pip install pytest pytest-asyncio pytest-cov # Run tests pytest # Run with coverage pytest --cov=voltagent --cov-report=html
cd voltagent-python # Context manager examples (recommended for most users) python examples/comprehensive_trace_example.py # Manual usage examples (for advanced control scenarios) python examples/manual_usage_examples.py
# Format code black . isort . # Type checking mypy . # Linting flake8 .
voltagent-python/
βββ voltagent/
β βββ __init__.py # Main package exports
β βββ types.py # Pydantic models and types
β βββ client.py # HTTP client (VoltAgentCoreAPI)
β βββ sdk.py # High-level SDK (VoltAgentSDK)
βββ tests/ # Comprehensive test suite
βββ examples/ # Usage examples
βββ requirements.txt # Dependencies
βββ README.md # This file
git checkout -b feature/amazing-feature)git commit -m 'Add amazing feature')git push origin feature/amazing-feature)MIT License - see LICENSE file for details.
VoltAgent/voltagent-python is a public repo on GitHub by VoltAgent. Its maker has not written a description.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2025-06-05. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
A curated collection of 1000+ agent skills from official dev teams and the community, compatible with Claude Code, Codex, Gemini CLI, Cursor, and more.
A collection of 100+ specialized Claude Code subagents covering a wide range of development use cases