ai-mirow-projects
/
swarms
mirror of https://github.com/kyegomez/swarms
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

docs, document lm fix, and corporate swarm cloud

Browse Source
pull/153/merge
Kye 1 year ago
parent 29579e3c28
commit 9b773353bd
10 changed files with 484 additions and 45 deletions
Show Stats Download Patch File Download Diff File

220
docs/corporate/swarm_cloud.md
Unescape View File

@ -0,0 +1,220 @@
# The Swarm Cloud
### Business Model Plan for Autonomous Agent Swarm Service
#### Service Description
- **Overview:** A platform allowing users to deploy swarms of autonomous agents in production-grade environments.
- **Target Users:** Industries requiring automation, monitoring, data collection, and more, such as manufacturing, logistics, agriculture, and surveillance.
#### Operational Strategy
- **Infrastructure:** Robust cloud infrastructure to support agent deployment and data processing.
- **Support and Maintenance:** Continuous support for software updates, troubleshooting, and user assistance.
- **Technology Development:** Ongoing R&D for enhancing agent capabilities and efficiency.
#### Financial Projections
- **Revenue Streams:** Mainly from per agent usage fees and hosting services.
- **Cost Structure:** Includes development, maintenance, infrastructure, marketing, and administrative costs.
- **Break-even Analysis:** Estimation based on projected user adoption rates and cost per agent.
#### Pricing Structure
- **Per Agent Usage Fee:** Charged based on the number of agents and the duration of their deployment.
- **Hosting Fees:** Based on the data usage and processing requirements of the agents.
- **Volume Discounts:** Available for large-scale deployments.
#### Theoretical Cost and Pricing (in Markdown Table)
```markdown
| Service Component | Cost per Agent | Basic Plan | Standard Plan | Premium Plan |
| ----------------- | -------------- | ---------- | ------------- | ------------ |
| Development Cost | $50 | Included | Included | Included |
| Deployment Cost | $30 | Included | Included | Included |
| Hosting (per month) | $20 | $100 | $250 | $500 |
| Maintenance (per month) | $15 | $50 | $125 | $250 |
| Additional Services | - | - | +10% | +20% |
| Volume Discount | - | - | 5% for >100 agents | 10% for >200 agents |
# Revnue Streams
```markdown
| Pricing Structure | Description | Details |
| ------------------------- | ----------- | ------- |
| Usage-Based Per Agent | Fees are charged based on the number of agents deployed and their usage duration. | - Ideal for clients needing a few agents for specific tasks. <br> - More agents or longer usage results in higher fees. |
| Swarm Coverage Pricing | Pricing based on the coverage area or scope of the swarm deployment. | - Suitable for tasks requiring large area coverage. <br> - Price scales with the size or complexity of the area covered. |
| Performance-Based Pricing | Fees are tied to the performance or outcomes achieved by the agents. | - Clients pay for the effectiveness or results achieved by the agents. <br> - Higher fees for more complex or high-value tasks. |
```
This table summarizes different pricing models, offering flexibility and scalability to cater to various client needs and deployment scenarios. Each pricing structure can be further tailored based on specific project requirements, market conditions, and operational costs.
## Unique Pricing:
Creating an innovative and diverse list of pricing structures and methods of value extraction for a service involving swarms of autonomous agents can help cater to various market segments and business needs. Here’s a comprehensive list:
1. **Pay-Per-Mission Pricing:** Clients are charged for each specific task or mission completed by the agents.
2. **Time-Based Subscription:** A subscription model where clients pay a recurring fee for continuous access to a set number of agents.
3. **Dynamic Pricing:** Prices fluctuate based on demand, time of day, or specific conditions.
4. **Tiered Usage Levels:** Different pricing tiers based on the number of agents used or the complexity of tasks.
5. **Freemium Model:** Basic services are free, but premium features or additional agents are paid.
6. **Outcome-Based Pricing:** Charges are based on the success or quality of the outcomes achieved by the agents.
7. **Feature-Based Pricing:** Different prices for different feature sets or capabilities of the agents.
8. **Volume Discounts:** Reduced per-agent price for bulk deployments or long-term contracts.
9. **Peak Time Premiums:** Higher charges during peak usage times or for emergency deployment.
10. **Bundled Services:** Combining agent services with other products or services for a comprehensive package deal.
11. **Custom Solution Pricing:** Tailor-made pricing for unique or specialized requirements.
12. **Data Analysis Fee:** Charging for the data processing and analytics provided by the agents.
13. **Performance Tiers:** Different pricing for varying levels of agent efficiency or performance.
14. **License Model:** Clients purchase a license to deploy and use a certain number of agents.
15. **Cost-Plus Pricing:** Pricing based on the cost of deployment plus a markup.
16. **Service Level Agreement (SLA) Pricing:** Higher prices for higher levels of service guarantees.
17. **Pay-Per-Save Model:** Charging based on the cost savings or value created by the agents for the client.
18. **Revenue Sharing:** Sharing a percentage of the revenue generated through the use of agents.
19. **Geographic Pricing:** Different pricing for different regions or markets.
20. **User-Based Pricing:** Charging based on the number of users accessing and controlling the agents.
21. **Energy Usage Pricing:** Prices based on the amount of energy consumed by the agents during operation.
22. **Event-Driven Pricing:** Charging for specific events or triggers during the agent's operation.
23. **Seasonal Pricing:** Adjusting prices based on seasonal demand or usage patterns.
24. **Partnership Models:** Collaborating with other businesses and sharing revenue from combined services.
25. **Customizable Packages:** Allowing clients to build their own package of services and capabilities, priced accordingly.
These diverse pricing strategies can be combined or tailored to fit different business models, client needs, and market dynamics. They also provide various methods of value extraction, ensuring flexibility and scalability in revenue generation.
# ICP Analysis
Creating an Ideal Customer Profile (ICP) map is crucial for identifying the potential first enterprise customer segments for a service involving swarms of autonomous agents. Below, I've outlined a comprehensive ICP map along with a market size table in markdown format, focusing on industries that could greatly benefit from such technology.
### Ideal Customer Profile (ICP) Map
#### 1. Manufacturing and Industrial Automation
- **Characteristics:** Large-scale manufacturers, high automation needs, emphasis on efficiency and precision.
- **Needs:** Process automation, quality control, predictive maintenance.
#### 2. Agriculture and Farming
- **Characteristics:** Large agricultural enterprises, focus on modern farming techniques.
- **Needs:** Crop monitoring, automated harvesting, pest control.
#### 3. Logistics and Supply Chain
- **Characteristics:** Companies with extensive logistics operations, warehousing, and supply chain management.
- **Needs:** Inventory tracking, automated warehousing, delivery optimization.
#### 4. Energy and Utilities
- **Characteristics:** Energy providers, utility companies, renewable energy farms.
- **Needs:** Infrastructure monitoring, predictive maintenance, efficiency optimization.
#### 5. Environmental Monitoring and Conservation
- **Characteristics:** Organizations focused on environmental protection, research institutions.
- **Needs:** Wildlife tracking, pollution monitoring, ecological research.
#### 6. Smart Cities and Urban Planning
- **Characteristics:** Municipal governments, urban development agencies.
- **Needs:** Traffic management, infrastructure monitoring, public safety.
#### 7. Defense and Security
- **Characteristics:** Defense contractors, security firms, government agencies.
- **Needs:** Surveillance, reconnaissance, threat assessment.
#### 8. Healthcare and Medical Facilities
- **Characteristics:** Large hospitals, medical research centers.
- **Needs:** Facility management, patient monitoring, medical logistics.
#### 9. Entertainment and Event Management
- **Characteristics:** Large-scale event organizers, theme parks.
- **Needs:** Crowd management, entertainment automation, safety monitoring.
#### 10. Construction and Infrastructure
- **Characteristics:** Major construction firms, infrastructure developers.
- **Needs:** Site monitoring, material tracking, safety compliance.
### Potential Market Size Table (in Markdown)
```markdown
| Customer Segment | Estimated Market Size (USD) | Notes |
| ---------------------------- | --------------------------- | ----- |
| Manufacturing and Industrial | $100 Billion | High automation and efficiency needs drive demand. |
| Agriculture and Farming | $75 Billion | Growing adoption of smart farming technologies. |
| Logistics and Supply Chain | $90 Billion | Increasing need for automation in warehousing and delivery. |
| Energy and Utilities | $60 Billion | Focus on infrastructure monitoring and maintenance. |
| Environmental Monitoring | $30 Billion | Rising interest in climate and ecological data collection. |
| Smart Cities and Urban Planning | $50 Billion | Growing investment in smart city technologies. |
| Defense and Security | $120 Billion | High demand for surveillance and reconnaissance tech. |
| Healthcare and Medical | $85 Billion | Need for efficient hospital management and patient care. |
| Entertainment and Event Management | $40 Billion | Innovative uses in crowd control and event safety. |
| Construction and Infrastructure | $70 Billion | Use in monitoring and managing large construction projects. |
```
This ICP map and market size table provide a strategic overview of potential first enterprise customer segments for swarm technology, along with an estimation of their market sizes. It's important to note that these figures are hypothetical and would require market research for accurate quantification.
#### Risk Analysis
- **Market Risks:** Adaptation rate and competition.
- **Operational Risks:** Reliability and scalability of infrastructure.
- **Regulatory Risks:** Compliance with data security and privacy laws.
# Business Model
---
### The Swarm Cloud: Business Model
#### Unlocking the Potential of Autonomous Agent Technology
**1. Our Vision:**
- Revolutionize industries through scalable, intelligent swarms of autonomous agents.
- Enable real-time data collection, analysis, and automated task execution.
**2. Service Offering:**
- **The Swarm Cloud Platform:** Deploy and manage swarms of autonomous agents in production-grade environments.
- **Applications:** Versatile across industries – from smart agriculture to urban planning, logistics, and beyond.
**3. Key Features:**
- **High Scalability:** Tailored solutions from small-scale deployments to large industrial operations.
- **Real-Time Analytics:** Instant data processing and actionable insights.
- **User-Friendly Interface:** Simplified control and monitoring of agent swarms.
- **Robust Security:** Ensuring data integrity and operational safety.
**4. Revenue Streams:**
- **Usage-Based Pricing:** Charges based on the number of agents and operation duration.
- **Subscription Models:** Recurring revenue through scalable packages.
- **Custom Solutions:** Tailored pricing for bespoke deployments.
**5. Market Opportunity:**
- **Expansive Market:** Addressing needs in a \$500 billion global market spanning multiple sectors.
- **Competitive Edge:** Advanced technology offering superior efficiency and adaptability.
**6. Growth Strategy:**
- **R&D Investment:** Continuous enhancement of agent capabilities and platform features.
- **Strategic Partnerships:** Collaborations with industry leaders for market penetration.
- **Marketing and Sales:** Focused approach on high-potential sectors with tailored marketing strategies.
**7. Why Invest in The Swarm Cloud?**
- **Pioneering Technology:** At the forefront of autonomous agent systems.
- **Scalable Business Model:** Designed for rapid expansion and adaptation to diverse market needs.
- **Strong Market Demand:** Positioned to capitalize on the growing trend of automation and AI.
"Empowering industries with intelligent, autonomous solutions – The Swarm Cloud is set to redefine efficiency and innovation."
#### Conclusion
The business model aims to provide a scalable, efficient, and cost-effective solution for industries looking to leverage the power of autonomous agent technology. With a structured pricing plan and a focus on continuous development and support, the service is positioned to meet diverse industry needs.

1
mkdocs.yml
Unescape View File

@ -134,3 +134,4 @@ nav:
- Architecture: "corporate/architecture.md"
- Checklist: "corporate/checklist.md"
- Hiring: "corporate/hiring.md"
- SwarmCloud: "corporate/swarm_cloud.md"

23
playground/demos/accountant_team/account_team2.py
Unescape View File

@ -31,24 +31,31 @@ llm2 = Anthropic(
doc_analyzer_agent = Flow(
llm=llm2,
sop=DOC_ANALYZER_AGENT_PROMPT,
max_loops="auto",
max_loops=1,
autosave=True,
saved_state_path="doc_analyzer_agent.json"
)
summary_generator_agent = Flow(
llm=llm2,
sop=SUMMARY_GENERATOR_AGENT_PROMPT,
max_loops="auto",
max_loops=1,
autosave=True,
saved_state_path="summary_generator_agent.json"
)
decision_making_support_agent = Flow(
llm=llm2,
sop=DECISION_MAKING_PROMPT,
max_loops="auto",
max_loops=1,
saved_state_path="decision_making_support_agent.json"
)
pdf_path="swarmdeck_a1.pdf"
fraud_detection_instructions="Detect fraud in the document"
summary_agent_instructions="Generate an actionable summary of the document"
decision_making_support_agent_instructions="Provide decision making support to the business owner:"
pdf_path = "bankstatement.pdf"
fraud_detection_instructions = "Detect fraud in the document"
summary_agent_instructions = "Generate an actionable summary of the document with action steps to take"
decision_making_support_agent_instructions = (
"Provide decision making support to the business owner:"
)
# Transform the pdf to text
@ -69,4 +76,4 @@ summary_agent_output = summary_generator_agent.run(
# Provide decision making support to the accountant
decision_making_support_agent_output = decision_making_support_agent.run(
f"{decision_making_support_agent_instructions}: {summary_agent_output}"
)
)

6
playground/demos/ai_research_team/main.py
Unescape View File

@ -34,7 +34,7 @@ paper_summarizer_agent = Flow(
sop=PAPER_SUMMARY_ANALYZER,
max_loops=1,
autosave=True,
saved_state_path='paper_summarizer.json'
saved_state_path="paper_summarizer.json",
)
paper_implementor_agent = Flow(
@ -42,9 +42,9 @@ paper_implementor_agent = Flow(
sop=PAPER_IMPLEMENTOR_AGENT_PROMPT,
max_loops=1,
autosave=True,
saved_state_path='paper_implementor.json'
saved_state_path="paper_implementor.json",
)
paper = pdf_to_text(PDF_PATH)
algorithmic_psuedocode_agent = paper_summarizer_agent.run(paper)
pytorch_code = paper_implementor_agent.run(algorithmic_psuedocode_agent)
pytorch_code = paper_implementor_agent.run(algorithmic_psuedocode_agent)

1
swarms/__init__.py
Unescape View File

@ -8,7 +8,6 @@ warnings.filterwarnings("ignore", category=UserWarning)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
try:
log = logging.getLogger("pytorch")
log.propagate = False
log.setLevel(logging.ERROR)

6
swarms/memory/qdrant.py
Unescape View File

@ -0,0 +1,6 @@
"""
QDRANT MEMORY CLASS
"""

153
swarms/models/huggingface.py
Unescape View File

@ -23,17 +23,92 @@ class HuggingfaceLLM:
verbose (bool, optional): Whether to print verbose logs. Defaults to False.
logger (logging.Logger, optional): The logger to use. Defaults to a basic logger.
# Usage
```
from swarms.models import HuggingfaceLLM
Methods:
run(task: str, max_length: int = 500) -> str:
Generate a response based on the prompt text.
model_id = "NousResearch/Yarn-Mistral-7b-128k"
inference = HuggingfaceLLM(model_id=model_id)
__call__(task: str, max_length: int = 500) -> str:
Generate a response based on the prompt text.
task = "Once upon a time"
generated_text = inference(task)
print(generated_text)
```
save_model(path: str):
Save the model to a given path.
gpu_available() -> bool:
Check if GPU is available.
memory_consumption() -> dict:
Get the memory consumption of the GPU.
print_dashboard(task: str):
Print dashboard.
set_device(device: str):
Changes the device used for inference.
set_max_length(max_length: int):
Set max_length.
set_verbose(verbose: bool):
Set verbose.
set_distributed(distributed: bool):
Set distributed.
set_decoding(decoding: bool):
Set decoding.
set_max_workers(max_workers: int):
Set max_workers.
set_repitition_penalty(repitition_penalty: float):
Set repitition_penalty.
set_no_repeat_ngram_size(no_repeat_ngram_size: int):
Set no_repeat_ngram_size.
set_temperature(temperature: float):
Set temperature.
set_top_k(top_k: int):
Set top_k.
set_top_p(top_p: float):
Set top_p.
set_quantize(quantize: bool):
Set quantize.
set_quantization_config(quantization_config: dict):
Set quantization_config.
set_model_id(model_id: str):
Set model_id.
set_model(model):
Set model.
set_tokenizer(tokenizer):
Set tokenizer.
set_logger(logger):
Set logger.
Examples:
>>> llm = HuggingfaceLLM(
... model_id="EleutherAI/gpt-neo-2.7B",
... device="cuda",
... max_length=500,
... quantize=True,
... quantization_config={
... "load_in_4bit": True,
... "bnb_4bit_use_double_quant": True,
... "bnb_4bit_quant_type": "nf4",
... "bnb_4bit_compute_dtype": torch.bfloat16,
... },
... )
>>> llm("Generate a 10,000 word blog on mental clarity and the benefits of meditation.")
'Generate a 10,000 word
"""
def __init__(
@ -343,3 +418,63 @@ class HuggingfaceLLM:
def clear_chat_history(self):
"""Clear chat history"""
self.chat_history = []
def set_verbose(self, verbose):
"""Set verbose"""
self.verbose = verbose
def set_distributed(self, distributed):
"""Set distributed"""
self.distributed = distributed
def set_decoding(self, decoding):
"""Set decoding"""
self.decoding = decoding
def set_max_workers(self, max_workers):
"""Set max_workers"""
self.max_workers = max_workers
def set_repitition_penalty(self, repitition_penalty):
"""Set repitition_penalty"""
self.repitition_penalty = repitition_penalty
def set_no_repeat_ngram_size(self, no_repeat_ngram_size):
"""Set no_repeat_ngram_size"""
self.no_repeat_ngram_size = no_repeat_ngram_size
def set_temperature(self, temperature):
"""Set temperature"""
self.temperature = temperature
def set_top_k(self, top_k):
"""Set top_k"""
self.top_k = top_k
def set_top_p(self, top_p):
"""Set top_p"""
self.top_p = top_p
def set_quantize(self, quantize):
"""Set quantize"""
self.quantize = quantize
def set_quantization_config(self, quantization_config):
"""Set quantization_config"""
self.quantization_config = quantization_config
def set_model_id(self, model_id):
"""Set model_id"""
self.model_id = model_id
def set_model(self, model):
"""Set model"""
self.model = model
def set_tokenizer(self, tokenizer):
"""Set tokenizer"""
self.tokenizer = tokenizer
def set_logger(self, logger):
"""Set logger"""
self.logger = logger

2
swarms/models/layoutlm_document_qa.py
Unescape View File

@ -28,7 +28,7 @@ class LayoutLMDocumentQA:
):
self.model_name = model_name
self.task_type = task_type
self.pipeline = pipeline(task_type, model=self.model_name)
self.pipeline = pipeline(task_type, model=model_name)
def __call__(self, task: str, img_path: str):
"""Call for model"""

2
swarms/prompts/ai_research_team.py
Unescape View File

@ -88,4 +88,4 @@ This SOP targets AI researchers and developers tasked with interpreting and impl
########## GENERATE THE ALGORITHMIC PSEUDOCODE OF THE NOVEL TECHNIQUE FROM THE PAPER #########
"""
"""

115
swarms/structs/flow.py
Unescape View File

@ -347,6 +347,7 @@ class Flow:
Flow Configuration:
Name: {self.agent_name}
Description: {self.agent_description}
Standard Operating Procedure: {self.sop}
System Prompt: {self.system_prompt}
Task: {task}
Max Loops: {self.max_loops}
@ -480,6 +481,97 @@ class Flow:
print(f"Error running flow: {error}")
raise
def __call__(self, task: str, **kwargs):
"""
Run the autonomous agent loop
Args:
task (str): The initial task to run
Flow:
1. Generate a response
2. Check stopping condition
3. If stopping condition is met, stop
4. If stopping condition is not met, generate a response
5. Repeat until stopping condition is met or max_loops is reached
"""
try:
# dynamic_prompt = self.construct_dynamic_prompt()
# combined_prompt = f"{dynamic_prompt}\n{task}"
# Activate Autonomous agent message
self.activate_autonomous_agent()
response = task # or combined_prompt
history = [f"{self.user_name}: {task}"]
# If dashboard = True then print the dashboard
if self.dashboard:
self.print_dashboard(task)
loop_count = 0
# for i in range(self.max_loops):
while self.max_loops == "auto" or loop_count < self.max_loops:
loop_count += 1
print(colored(f"\nLoop {loop_count} of {self.max_loops}", "blue"))
print("\n")
if self.stopping_token:
if self._check_stopping_condition(response) or parse_done_token(
response
):
break
# Adjust temperature, comment if no work
if self.dynamic_temperature:
self.dynamic_temperature()
# Preparing the prompt
task = self.agent_history_prompt(FLOW_SYSTEM_PROMPT, response)
attempt = 0
while attempt < self.retry_attempts:
try:
response = self.llm(
task,
**kwargs,
)
# If there are any tools then parse and execute them
# if self.tools:
# self.parse_and_execute_tools(response)
if self.interactive:
print(f"AI: {response}")
history.append(f"AI: {response}")
response = input("You: ")
history.append(f"Human: {response}")
else:
print(f"AI: {response}")
history.append(f"AI: {response}")
# print(response)
break
except Exception as e:
logging.error(f"Error generating response: {e}")
attempt += 1
time.sleep(self.retry_interval)
history.append(response)
time.sleep(self.loop_interval)
self.memory.append(history)
if self.autosave:
save_path = self.saved_state_path or "flow_state.json"
print(colored(f"Autosaving flow state to {save_path}", "green"))
self.save_state(save_path)
if self.return_history:
return response, history
return response
except Exception as error:
print(f"Error running flow: {error}")
raise
async def arun(self, task: str, **kwargs):
"""
Run the autonomous agent loop aschnronously
@ -947,28 +1039,7 @@ class Flow:
Args:
**kwargs (Any): Any additional keyword arguments
"""
# Run the flow
response = self.run_with_timeout("flow")
# If an error occurs, save the state
if not self.validate_response(response):
self.save_state("previous_state.txt")
# Refactor the code
self.refactor_code()
# Run the flow again
response = self.run_with_timeout("flow")
# If the error occurs again, revert to the previous state
if not self.validate_response(response):
self.load_state("previous_state.txt")
# If the error does not occur, continue
else:
print("Self-healing successful! Bug fixed!")
return response
pass
def refactor_code(self):
"""

Write Preview
Loading…
Cancel
Save