Metadata-Version: 2.3
Name: agori
Version: 0.1.4
Summary: AI-powered decision-making frameworks for enhancing group decisions
Project-URL: Homepage, https://github.com/govindshukl/agori
Project-URL: Bug Tracker, https://github.com/govindshukl/agori/issues
Project-URL: Repository, https://github.com/govindshukl/agori.git
Project-URL: Documentation, https://github.com/govindshukl/agori#readme
Author-email: Govind Shukla <govind.shukl@gmail.com>
Keywords: ai-frameworks,artificial-intelligence,azure-openai,collaborative-decision-making,decision-making,group-decision,langchain,nominal-group-technique
Requires-Python: >=3.8
Requires-Dist: chromadb
Requires-Dist: cryptography
Requires-Dist: langchain
Requires-Dist: langchain-community
Requires-Dist: langchain-core
Requires-Dist: langchain-openai
Requires-Dist: numpy
Requires-Dist: pandas
Requires-Dist: pypdf
Requires-Dist: pytest-asyncio
Requires-Dist: python-dotenv
Requires-Dist: tenacity
Requires-Dist: tiktoken
Provides-Extra: docs
Requires-Dist: mkdocs-material>=9.0.0; extra == 'docs'
Requires-Dist: mkdocs>=1.4.0; extra == 'docs'
Requires-Dist: mkdocstrings>=0.20.0; extra == 'docs'
Provides-Extra: test
Requires-Dist: black>=23.0.0; extra == 'test'
Requires-Dist: flake8>=6.0.0; extra == 'test'
Requires-Dist: mypy>=1.0.0; extra == 'test'
Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
Requires-Dist: pytest-mock>=3.10.0; extra == 'test'
Requires-Dist: pytest>=7.0.0; extra == 'test'
Requires-Dist: types-requests>=2.0.0; extra == 'test'
Description-Content-Type: text/markdown

# Agori

Agori is a Python package that implements various decision-making frameworks powered by generative AI. It aims to enhance group decision-making processes by leveraging the capabilities of large language models.

## Currently Supported Frameworks

### 1. Nominal Group Technique (NGT)
The Nominal Group Technique is a structured decision-making method that helps groups reach consensus through a systematic process of idea generation and evaluation. Our implementation enhances this process using AI to:
- Generate diverse expert perspectives
- Analyze problems from multiple angles
- Synthesize insights into actionable recommendations

## Installation

```bash
pip install agori
```

## Quick Start

Here's a simple example using the NGT framework:

```python
import asyncio
from agori.decision_frameworks.ngt import NGTProcessor 
from langchain_community.document_loaders import PyPDFLoader

async def analyze_document(document_path: str, query: str):
    # Load document
    loader = PyPDFLoader(document_path)
    pages = loader.load()
    
    # Initialize NGT processor
    ngt = NGTProcessor(
        deployment="your-deployment",
        endpoint="your-endpoint", 
        api_key="your-api-key",
        api_version="your-api-version",
        verbose=True
    )

    # Add documents
    ngt.add_documents(pages)
    
    # Run analysis
    result = await ngt.run_ngt_analysis(query)
    return result

# Run analysis
document_path = "your_document.pdf"
query = "What strategic decisions should we make based on this document?"
result = await analyze_document(document_path, query)
```

## Features

### NGT Framework
- **Expert Role Generation**: Automatically identifies relevant expert perspectives based on the problem context
- **Multi-perspective Analysis**: Analyzes problems from different expert viewpoints
- **Parallel Processing**: Efficiently processes large documents using concurrent analysis
- **Structured Output**: Provides organized insights with clear recommendations
- **Configurable Parameters**: Allows customization of processing parameters
- **Detailed Logging**: Offers verbose mode for tracking the decision-making process

## Configuration

The NGT processor accepts various configuration parameters:

```python
from agori.decision_frameworks.ngt.models import Config

config = Config(
    MAX_TOKENS_PER_REQUEST=126000,
    CHUNK_SIZE=31500,
    CHUNK_OVERLAP=2000,
    MAX_WORKERS=3,
    MAX_PARALLEL_REQUESTS=3,
    VERBOSE=True
)

ngt = NGTProcessor(
    deployment="your-deployment",
    endpoint="your-endpoint", 
    api_key="your-api-key",
    api_version="your-api-version",
    config=config
)
```

## Advanced Usage

### Step-by-Step Process

You can also run the NGT process step by step:

```python
# Generate experts
experts = await ngt.generate_experts(query)

# Generate expert responses
expert_responses = await ngt.analyze_with_experts(experts, query)

# Synthesize results
synthesis = await ngt.synthesize_ngt_results(expert_responses)
```

### Error Handling

The package includes custom exceptions for better error handling:

```python
from agori.decision_frameworks.ngt import (
    NGTError,
    ExpertGenerationError,
    IdeaGenerationError,
    SynthesisError
)

try:
    result = await ngt.run_ngt_analysis(query)
except ExpertGenerationError as e:
    print(f"Error generating experts: {e}")
except IdeaGenerationError as e:
    print(f"Error generating ideas: {e}")
except SynthesisError as e:
    print(f"Error synthesizing results: {e}")
except NGTError as e:
    print(f"General NGT error: {e}")
```

## Dependencies

- langchain
- tiktoken
- azure-openai
- asyncio
- typing
- dataclasses

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

## License

[MIT License](LICENSE)

## Project Status

This project is actively under development. The NGT framework is the first implementation, with more decision-making frameworks planned for future releases.

## Roadmap

- [ ] Additional decision frameworks
- [ ] Working memory for intermediate results caching
- [ ] Support for more LLM providers
- [ ] Integration with decision support tools


## Citation

If you use Agori in your research, please cite:

```bibtex
@software{agori2024,
  title = {Agori: AI-Powered Decision Frameworks},
  year = {2024},
  url = {https://github.com/govindshukl/agori}
}
```

## Contact

For questions and feedback, please open an issue on the GitHub repository.