LRS-Agents

Getting Started

  • Installation
    • Requirements
    • Basic Installation
    • Installation with Optional Dependencies
      • All Features
      • LangChain Integration
      • OpenAI Integration
      • Monitoring & Visualization
      • Development
    • Installation from Source
      • Development Installation
    • Verify Installation
      • Quick Test
    • Configuration
      • API Keys
      • Environment Variables
    • Docker Installation
    • Kubernetes Deployment
    • Troubleshooting
      • Import Errors
      • Missing Dependencies
      • Version Conflicts
      • GPU Support
    • Getting Help
    • Next Steps
  • Quickstart
    • Overview
    • Step 1: Install LRS-Agents
    • Step 2: Set API Key
    • Step 3: Create Your First Tool
    • Step 4: Create an LRS Agent
    • Step 5: Run a Task
    • Understanding the Output
      • Example Output
    • What Just Happened?
    • Key Concepts
      • Precision (γ)
      • Prediction Error
      • Expected Free Energy (G)
      • Adaptation
    • Next Steps
    • Common Patterns
      • Multiple Alternatives
      • Tool Composition
      • Monitoring
    • Troubleshooting
      • Agent Always Fails
      • No Adaptation
      • High Step Count
    • Further Reading
  • Core Concepts
    • Active Inference
      • What is Active Inference?
      • Why Active Inference for AI?
    • The Free Energy Principle
      • Expected Free Energy (G)
      • Low G = Good Policy
      • Example Calculation
    • Precision Tracking
      • What is Precision?
      • How Precision Updates
      • Example
    • Hierarchical Precision
      • Three Levels
      • Why Hierarchy?
      • Error Propagation
    • Prediction Errors
      • What Are They?
      • How to Set Them
      • Why They Matter
    • Tool Lenses
      • What is a Lens?
      • Why Lenses?
      • Example
      • Composition
    • Policy Selection
      • How Policies are Selected
      • Precision-Weighted Selection
        • High Precision (γ > 0.7)
        • Low Precision (γ < 0.4)
    • Adaptation
      • When Does It Happen?
      • What Happens?
      • Example Scenario
    • Multi-Agent Concepts
      • Social Precision
      • Communication as Information-Seeking
    • Putting It All Together
      • The LRS Agent Loop
    • Key Takeaways
    • Next Steps

User Guides

  • LangChain Integration
    • Overview
    • Quick Start
      • Convert a LangChain Tool
    • Using LangChain Tools
      • Basic Wrapper
      • Advanced Wrapper
    • Common LangChain Tools
      • Web Search
      • Wikipedia
      • Python REPL
      • File Operations
    • Using LangChain Agents with LRS
    • LangChain + LRS Hybrid
    • Using LangChain Chains
    • LangGraph Integration
    • Error Handling
      • Timeouts
      • Rate Limits
      • Network Errors
    • Best Practices
      • 1. Set Appropriate Timeouts
      • 2. Provide Custom Error Functions
      • 3. Register Alternatives
      • 4. Monitor Performance
    • Complete Example
    • Troubleshooting
      • Tool Not Working
      • High Prediction Errors
      • Agent Not Adapting
    • Next Steps
  • OpenAI Assistants Integration
    • Overview
    • Quick Start
      • Basic Setup
    • Using Assistants for Policy Generation
      • Basic Policy Generator
      • Custom Assistant
    • Precision-Adaptive Temperature
    • Using Built-in Assistant Tools
      • Code Interpreter
      • File Search
      • Function Calling
    • Complete Agent Example
    • Handling Long-Running Operations
    • Error Handling
      • Rate Limits
      • Timeouts
    • Best Practices
      • 1. Provide Clear Instructions
      • 2. Monitor Performance
      • 3. Combine with Custom Tools
      • 4. Set Appropriate Timeouts
    • Cost Optimization
      • Minimize Costs
      • Cache Responses
    • Troubleshooting
      • Assistant Not Responding
      • Poor Proposals
      • High Costs
    • Next Steps
  • AutoGPT Integration
    • Overview
    • Quick Start
      • Basic AutoGPT Agent
    • Converting AutoGPT Commands to LRS Tools
      • Automatic Conversion
      • Custom Prediction Errors
    • Common AutoGPT Commands
      • File Operations
      • Web Operations
      • Code Execution
    • Complete Research Agent Example
    • Handling AutoGPT Loops
      • Traditional AutoGPT Loop
      • LRS-Enhanced Loop
    • Precision Dynamics in Research
      • Example Execution Trace
    • Monitoring and Logging
      • Real-time Monitoring
      • Structured Logging
    • Best Practices
      • 1. Define Clear Goals
      • 2. Provide Diverse Commands
      • 3. Set Reasonable Iteration Limits
      • 4. Monitor Command Performance
    • Troubleshooting
      • Agent Gets Stuck
      • Agent Doesn’t Adapt
      • High Iteration Count
    • Comparison with Standard AutoGPT
    • Next Steps
  • Production Deployment
    • Overview
    • Architecture
      • Recommended Stack
    • Docker Deployment
      • Basic Docker Setup
      • Docker Compose
    • Kubernetes Deployment
      • Basic Deployment
      • Production Configuration
    • Monitoring
      • Structured Logging
      • Log Aggregation
      • Metrics and Alerting
      • Dashboard
    • Database Management
      • Schema Setup
      • Connection Pooling
      • Backup Strategy
    • Security
      • API Authentication
      • Environment Variables
      • Rate Limiting
    • Performance Optimization
      • Caching
      • Async Execution
      • Resource Limits
    • Health Checks
    • Troubleshooting
      • Common Issues
      • Debug Mode
    • Checklist
    • Next Steps
    • Further Reading

API Reference

  • Core Components
    • Precision Tracking
      • PrecisionParameters
        • PrecisionParameters.alpha
        • PrecisionParameters.beta
        • PrecisionParameters.gain_learning_rate
        • PrecisionParameters.loss_learning_rate
        • PrecisionParameters.adaptation_threshold
        • PrecisionParameters.value
        • PrecisionParameters.variance
        • PrecisionParameters.update()
        • PrecisionParameters.should_adapt()
        • PrecisionParameters.reset()
        • PrecisionParameters.get_all()
        • PrecisionParameters.learning_rate_gain
        • PrecisionParameters.learning_rate_loss
        • PrecisionParameters.threshold
        • PrecisionParameters.get_all_values()
        • PrecisionParameters.__init__()
      • HierarchicalPrecision
        • HierarchicalPrecision.propagation_threshold
        • HierarchicalPrecision.attenuation_factor
        • HierarchicalPrecision.abstract
        • HierarchicalPrecision.planning
        • HierarchicalPrecision.execution
        • HierarchicalPrecision.get_level()
        • HierarchicalPrecision.update()
        • HierarchicalPrecision.get_all_values()
        • HierarchicalPrecision.get_all()
        • HierarchicalPrecision.reset()
        • HierarchicalPrecision.should_adapt()
        • HierarchicalPrecision.__init__()
      • beta_mean()
      • beta_variance()
    • Tool Lenses
      • ExecutionResult
        • ExecutionResult.success
        • ExecutionResult.value
        • ExecutionResult.error
        • ExecutionResult.prediction_error
        • ExecutionResult.success
        • ExecutionResult.value
        • ExecutionResult.error
        • ExecutionResult.prediction_error
        • ExecutionResult.__init__()
      • ToolLens
        • ToolLens.name
        • ToolLens.input_schema
        • ToolLens.output_schema
        • ToolLens.call_count
        • ToolLens.failure_count
        • ToolLens.__init__()
        • ToolLens.get()
        • ToolLens.set()
        • ToolLens.success_rate
      • ComposedLens
        • ComposedLens.left
        • ComposedLens.right
        • ComposedLens.__init__()
        • ComposedLens.get()
        • ComposedLens.set()
    • Tool Registry
      • ToolRegistry
        • ToolRegistry.tools
        • ToolRegistry.alternatives
        • ToolRegistry.statistics
        • ToolRegistry.__init__()
        • ToolRegistry.register()
        • ToolRegistry.get_tool()
        • ToolRegistry.find_alternatives()
        • ToolRegistry.discover_compatible_tools()
        • ToolRegistry.update_statistics()
        • ToolRegistry.get_statistics()
        • ToolRegistry.list_tools()
    • Free Energy
      • PolicyEvaluation
        • PolicyEvaluation.epistemic_value
        • PolicyEvaluation.pragmatic_value
        • PolicyEvaluation.total_G
        • PolicyEvaluation.expected_success_prob
        • PolicyEvaluation.components
        • PolicyEvaluation.__init__()
      • calculate_epistemic_value()
      • calculate_pragmatic_value()
      • calculate_expected_free_energy()
      • evaluate_policy()
      • precision_weighted_selection()
  • Inference API
    • Meta-Cognitive Prompting
      • StrategyMode
        • StrategyMode.EXPLOITATION
        • StrategyMode.EXPLORATION
        • StrategyMode.BALANCED
      • PromptContext
        • PromptContext.precision
        • PromptContext.recent_errors
        • PromptContext.available_tools
        • PromptContext.goal
        • PromptContext.state
        • PromptContext.tool_history
        • PromptContext.precision
        • PromptContext.recent_errors
        • PromptContext.available_tools
        • PromptContext.goal
        • PromptContext.state
        • PromptContext.tool_history
        • PromptContext.__init__()
      • MetaCognitivePrompter
        • MetaCognitivePrompter.__init__()
        • MetaCognitivePrompter.generate_prompt()
      • build_simple_prompt()
      • Classes
        • PromptContext
        • StrategyMode
        • MetaCognitivePrompter
    • LLM Policy Generator
      • PolicyProposal
        • PolicyProposal.tool_sequence
        • PolicyProposal.reasoning
        • PolicyProposal.estimated_success_prob
        • PolicyProposal.estimated_info_gain
        • PolicyProposal.strategy
        • PolicyProposal.failure_modes
        • PolicyProposal.validate_strategy()
        • PolicyProposal.model_config
      • PolicyProposalSet
        • PolicyProposalSet.proposals
        • PolicyProposalSet.current_uncertainty
        • PolicyProposalSet.known_unknowns
        • PolicyProposalSet.model_config
      • LLMPolicyGenerator
        • LLMPolicyGenerator.__init__()
        • LLMPolicyGenerator.generate_proposals()
      • create_mock_generator()
      • Classes
        • PolicyProposal
        • PolicyProposalSet
        • LLMPolicyGenerator
      • Functions
        • create_mock_generator()
    • Hybrid Evaluator
      • HybridGEvaluator
        • HybridGEvaluator.__init__()
        • HybridGEvaluator.evaluate_hybrid()
        • HybridGEvaluator.evaluate_all()
      • compare_math_vs_llm()
      • Classes
        • HybridGEvaluator
      • Functions
        • compare_math_vs_llm()
  • Integration API
    • LangGraph
      • LRSState
        • LRSState.messages
        • LRSState.precision
        • LRSState.precision_history
        • LRSState.candidate_policies
        • LRSState.policy_evaluations
        • LRSState.selected_policy
        • LRSState.current_policy_index
        • LRSState.tool_history
        • LRSState.current_hbn_level
        • LRSState.belief_state
        • LRSState.adaptation_count
        • LRSState.adaptation_events
        • LRSState.goal
        • LRSState.preferences
      • LRSGraphBuilder
        • LRSGraphBuilder.llm
        • LRSGraphBuilder.registry
        • LRSGraphBuilder.precision_manager
        • LRSGraphBuilder.preferences
        • LRSGraphBuilder.__init__()
        • LRSGraphBuilder.build()
      • create_lrs_agent()
      • create_monitored_lrs_agent()
      • Classes
        • LRSGraphBuilder
      • TypedDicts
        • LRSState
      • Functions
        • create_lrs_agent()
    • LangChain Adapter
      • LangChainToolLens
        • LangChainToolLens.__init__()
        • LangChainToolLens.get()
        • LangChainToolLens.set()
      • wrap_langchain_tool()
      • Classes
        • LangChainToolLens
      • Functions
        • wrap_langchain_tool()
    • OpenAI Assistants
      • OpenAIAssistantLens
        • OpenAIAssistantLens.__init__()
        • OpenAIAssistantLens.get()
        • OpenAIAssistantLens.set()
      • OpenAIAssistantPolicyGenerator
        • OpenAIAssistantPolicyGenerator.__init__()
        • OpenAIAssistantPolicyGenerator.generate_proposals()
      • create_openai_lrs_agent()
      • Classes
        • OpenAIAssistantLens
        • OpenAIAssistantPolicyGenerator
      • Functions
        • create_openai_lrs_agent()
    • AutoGPT Adapter
      • AutoGPTCommand
        • AutoGPTCommand.__init__()
        • AutoGPTCommand.get()
        • AutoGPTCommand.set()
      • LRSAutoGPTAgent
        • LRSAutoGPTAgent.__init__()
        • LRSAutoGPTAgent.run()
      • convert_autogpt_to_lrs()
      • Classes
        • AutoGPTCommand
        • LRSAutoGPTAgent
      • Functions
        • convert_autogpt_to_lrs()
  • Monitoring API
    • State Tracking
      • StateSnapshot
        • StateSnapshot.timestamp
        • StateSnapshot.precision
        • StateSnapshot.prediction_errors
        • StateSnapshot.tool_history
        • StateSnapshot.adaptation_count
        • StateSnapshot.belief_state
        • StateSnapshot.timestamp
        • StateSnapshot.precision
        • StateSnapshot.prediction_errors
        • StateSnapshot.tool_history
        • StateSnapshot.adaptation_count
        • StateSnapshot.belief_state
        • StateSnapshot.__init__()
      • LRSStateTracker
        • LRSStateTracker.__init__()
        • LRSStateTracker.track_state()
        • LRSStateTracker.get_precision_trajectory()
        • LRSStateTracker.get_all_precision_trajectories()
        • LRSStateTracker.get_prediction_errors()
        • LRSStateTracker.get_adaptation_events()
        • LRSStateTracker.get_tool_usage_stats()
        • LRSStateTracker.get_current_state()
        • LRSStateTracker.export_history()
        • LRSStateTracker.clear()
        • LRSStateTracker.get_summary()
      • Classes
        • LRSStateTracker.track_state()
        • LRSStateTracker.get_precision_trajectory()
        • LRSStateTracker.get_all_precision_trajectories()
        • LRSStateTracker.get_prediction_errors()
        • LRSStateTracker.get_adaptation_events()
        • LRSStateTracker.get_tool_usage_stats()
        • LRSStateTracker.get_summary()
        • LRSStateTracker.export_history()
        • LRSStateTracker.clear()
    • Structured Logging
      • Classes
        • LRSLogger.log_precision_update()
        • LRSLogger.log_policy_selection()
        • LRSLogger.log_tool_execution()
        • LRSLogger.log_adaptation_event()
        • LRSLogger.log_performance_metrics()
        • LRSLogger.log_error()
      • Functions
    • Dashboard (Optional)
      • create_dashboard()
      • run_dashboard()

Theory

  • Active Inference
    • Overview
    • The Core Principle
      • Free Energy Minimization
      • Two Ways to Minimize Free Energy
    • Active Inference for AI Agents
      • Traditional RL vs Active Inference
      • Key Insight
    • Mathematical Framework
      • Generative Model
      • Variational Free Energy
      • Expected Free Energy
      • Precision-Weighted Beliefs
    • How LRS-Agents Implements Active Inference
      • 1. Generative Model
      • 2. Precision Tracking
      • 3. Expected Free Energy Calculation
      • 4. Policy Selection
      • 5. Hierarchical Inference
    • Active Inference vs Other Approaches
      • Comparison Table
      • Advantages of Active Inference
    • Theoretical Foundations
      • Predictive Processing
      • Precision-Weighting
      • Bayesian Brain Hypothesis
      • Markov Blanket
    • Real-World Applications
      • Robotics
      • Autonomous Vehicles
      • Clinical Applications
      • AI Safety
    • Limitations and Open Questions
      • Computational Complexity
      • Model Misspecification
      • Precision Learning
    • Mathematical Details
      • Variational Message Passing
      • Dynamic Causal Modeling
      • Generalized Free Energy
    • Further Reading
      • Foundational Papers
      • Books
      • Implementations
    • Next Steps
  • Free Energy
    • Overview
    • What is Expected Free Energy?
      • Definition
      • Intuitive Explanation
      • Decomposition
      • The Trade-off
    • Epistemic Value Calculation
      • Definition
      • In LRS-Agents
      • Calculation Details
      • Example
    • Pragmatic Value Calculation
      • Definition
      • In LRS-Agents
      • Calculation Details
      • Example
    • Total Expected Free Energy
      • Formula
      • In LRS-Agents
      • Detailed Example
    • Precision-Weighted Selection
      • Softmax Selection
      • Example
      • Precision-Dependent Behavior
    • Adaptive G Evaluation
      • Epistemic Weight Adaptation
      • Context-Dependent G
      • Multiple Objectives
    • Hybrid G Evaluation
      • LLM + Mathematical G
      • Why Hybrid?
    • Edge Cases and Special Scenarios
      • Empty Policy
      • Single Tool
      • Long Policies
      • Novel Tools
      • Failed Policies
    • Implementation Details
      • Caching
      • Numerical Stability
      • Batch Evaluation
      • Validation
      • Debugging
    • Further Reading
    • Next Steps
  • Precision Dynamics
    • Overview
    • What is Precision?
      • Definition
      • Bayesian Formulation
      • Initial Values
    • Precision Updates
      • Update Rule
      • Asymmetric Learning
      • Update Examples
    • Precision-Dependent Behavior
      • Policy Selection
      • Epistemic Weight
      • LLM Temperature
    • Adaptation Trigger
      • When Does Adaptation Happen?
      • What Happens During Adaptation?
      • Adaptation Example
    • Hierarchical Precision
      • Three Levels
      • Error Propagation
      • Hierarchical Behavior
    • Precision Collapse
      • What is Precision Collapse?
      • Prevention
      • Recovery Strategies
    • Social Precision
      • Multi-Agent Precision
      • Social Precision Updates
      • Communication Decisions
      • Theory-of-Mind
    • Precision Dynamics in Practice
      • Tuning Learning Rates
      • Monitoring Precision
      • Analyzing Adaptation Events
      • Precision-Based Metrics
    • Mathematical Details
      • Beta Distribution Properties
      • Bayesian Update Interpretation
      • Continuous-Time Dynamics
      • Simulation Example
    • Common Pitfalls
      • 1. Precision Too High
      • 2. Precision Too Low
      • 3. Oscillating Precision
      • 4. Ignoring Variance
    • Future Directions
      • Meta-Learning Precision
      • Context-Dependent Precision
      • Ensemble Precision
    • Further Reading
      • References
    • Next Steps
LRS-Agents
  • Search

© Copyright 2024-2025, LRS-Agents Contributors.

Built with Sphinx using a theme provided by Read the Docs.