"""
Pattern 37: Community Pattern
Agents form communities based on shared interests, goals, or characteristics.
Social structures with norms, reputation, and collective identity emerge organically.
"""
from typing import Dict, Any, List, Optional, Set
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
@dataclass
class CommunityMember:
"""Member of a community."""
name: str
interests: List[str]
reputation: float = 0.5 # 0.0-1.0
contributions: int = 0
communities: Set[str] = field(default_factory=set)
@dataclass
class Community:
"""A community of agents."""
name: str
focus: str
members: Set[str] = field(default_factory=set)
norms: List[str] = field(default_factory=list)
events: List[Dict[str, Any]] = field(default_factory=list)
class CommunityPattern:
"""
Community Pattern - Social organization around shared interests.
Features:
- Interest-based clustering
- Reputation systems
- Community norms
- Collective activities
- Inter-community connections
"""
def __init__(self, model_name: str = "gpt-4"):
self.llm = ChatOpenAI(model=model_name, temperature=0.7)
self.members: Dict[str, CommunityMember] = {}
self.communities: Dict[str, Community] = {}
def add_member(self, member: CommunityMember):
"""Add member to the system."""
self.members[member.name] = member
print(f"ā Added member: {member.name} - Interests: {', '.join(member.interests)}")
def create_community(self, name: str, focus: str, norms: List[str]) -> Community:
"""Create a new community."""
community = Community(name, focus, norms=norms)
self.communities[name] = community
print(f"ā Created community: {name} (Focus: {focus})")
return community
def join_community(self, member_name: str, community_name: str) -> bool:
"""Member joins a community."""
if member_name in self.members and community_name in self.communities:
self.members[member_name].communities.add(community_name)
self.communities[community_name].members.add(member_name)
print(f"ā {member_name} joined {community_name}")
return True
return False
def suggest_communities(self, member_name: str) -> List[str]:
"""Suggest communities based on interests."""
if member_name not in self.members:
return []
member = self.members[member_name]
suggestions = []
for comm_name, comm in self.communities.items():
if comm_name not in member.communities:
# Check interest overlap
if any(interest.lower() in comm.focus.lower()
for interest in member.interests):
suggestions.append(comm_name)
return suggestions
def contribute(self, member_name: str, community_name: str, contribution: str):
"""Member contributes to community."""
if member_name in self.members and community_name in self.communities:
member = self.members[member_name]
community = self.communities[community_name]
member.contributions += 1
member.reputation = min(1.0, member.reputation + 0.05)
event = {
"type": "contribution",
"member": member_name,
"description": contribution,
"timestamp": datetime.now()
}
community.events.append(event)
print(f"ā {member_name} contributed to {community_name}: {contribution}")
print(f" Reputation: {member.reputation:.2f}")
def organize_event(self, community_name: str, event_description: str) -> Dict[str, Any]:
"""Community organizes an event."""
if community_name not in self.communities:
return {}
community = self.communities[community_name]
event = {
"type": "event",
"community": community_name,
"description": event_description,
"participants": list(community.members),
"timestamp": datetime.now()
}
community.events.append(event)
return event
def get_top_contributors(self, community_name: str, n: int = 3) -> List[Dict[str, Any]]:
"""Get top contributors in a community."""
if community_name not in self.communities:
return []
community = self.communities[community_name]
members = [self.members[m] for m in community.members if m in self.members]
members.sort(key=lambda x: (x.contributions, x.reputation), reverse=True)
return [
{"name": m.name, "contributions": m.contributions, "reputation": m.reputation}
for m in members[:n]
]
def run(self, scenario: str) -> Dict[str, Any]:
"""Execute community scenario."""
total_events = sum(len(c.events) for c in self.communities.values())
avg_community_size = sum(len(c.members) for c in self.communities.values()) / len(self.communities) if self.communities else 0
return {
"pattern": "Community",
"scenario": scenario,
"members": len(self.members),
"communities": len(self.communities),
"total_events": total_events,
"avg_community_size": avg_community_size
}
# Example usage
if __name__ == "__main__":
print("=== Community Pattern Demo ===\n")
pattern = CommunityPattern()
# Add members
print("--- Adding Members ---")
members = [
CommunityMember("Alice", ["Python", "AI", "Open Source"]),
CommunityMember("Bob", ["Design", "UX", "Open Source"]),
CommunityMember("Carol", ["Python", "Data Science", "Research"]),
CommunityMember("David", ["AI", "Research", "Ethics"]),
]
for member in members:
pattern.add_member(member)
# Create communities
print("\n--- Creating Communities ---")
pattern.create_community("PythonDevs", "Python Programming",
["Share knowledge", "Help beginners", "Code quality"])
pattern.create_community("AIResearchers", "AI and Machine Learning",
["Peer review", "Reproducibility", "Ethical AI"])
pattern.create_community("OpenSourceContributors", "Open Source Development",
["Collaboration", "Documentation", "Community-first"])
# Members join communities
print("\n--- Members Joining Communities ---")
pattern.join_community("Alice", "PythonDevs")
pattern.join_community("Alice", "OpenSourceContributors")
pattern.join_community("Carol", "PythonDevs")
pattern.join_community("David", "AIResearchers")
# Suggest communities
print("\n--- Community Suggestions ---")
for member_name in ["Bob", "Carol"]:
suggestions = pattern.suggest_communities(member_name)
if suggestions:
print(f"{member_name} might like: {', '.join(suggestions)}")
# Member contributions
print("\n--- Member Contributions ---")
pattern.contribute("Alice", "PythonDevs", "Wrote tutorial on async programming")
pattern.contribute("Carol", "PythonDevs", "Fixed bugs in pandas integration")
pattern.contribute("David", "AIResearchers", "Published ethics framework")
pattern.contribute("Alice", "PythonDevs", "Mentored 3 new members")
# Organize community events
print("\n--- Community Events ---")
event = pattern.organize_event("PythonDevs", "Weekly coding meetup")
print(f"ā Event in {event['community']}: {event['description']}")
print(f" Participants: {', '.join(event['participants'])}")
# Top contributors
print("\n--- Top Contributors ---")
top = pattern.get_top_contributors("PythonDevs")
for i, contributor in enumerate(top, 1):
print(f"{i}. {contributor['name']}: {contributor['contributions']} contributions, "
f"reputation {contributor['reputation']:.2f}")
# Summary
print("\n--- Summary ---")
result = pattern.run("Developer communities")
print(f"Total Members: {result['members']}")
print(f"Total Communities: {result['communities']}")
print(f"Total Events: {result['total_events']}")
print(f"Avg Community Size: {result['avg_community_size']:.1f}")
result = pattern.run("Test input")
print(f"Result: {result}")
Agentic Architecture Pattern: Community
Pattern 37: 37 Community – Line-by-Line Explanation
Overview
Pattern 37: Community Pattern
Agents form communities based on shared interests, goals, or characteristics. Social structures with norms, reputation, and collective identity emerge organically.
Code Structure Analysis
File Information
- Pattern Number: 37
- Pattern Name: 37 Community
- File Path:
patterns\organizational\37_community.py - Total Lines: 226
Detailed Code Explanation
Module Docstring
"""
Pattern 37: Community Pattern
Agents form communities based on shared interests, goals, or characteristics.
Social structures with norms, reputation, and collective identity emerge organically.
"""
Explanation: This module docstring describes the purpose and key features of the 37 Community pattern.
Imports Section
from typing import Dict, Any, List, Optional, Set
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI # First 20 imports shown
Explanation: The module imports necessary dependencies:
– from typing import Dict, Any, List, Optional, Set: Type hints for better code documentation
– from dataclasses import dataclass, field: Data class decorators for clean data structures
– from datetime import datetime: Date and time utilities
– from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration
– from langchain_openai import ChatOpenAI: LangChain framework integration
Classes
CommunityMember (Line 16)
Description: Member of a community.
Community (Line 26)
Description: A community of agents.
CommunityPattern (Line 35)
Description: Community Pattern – Social organization around shared interests.
Features: – Interest-based clustering – Reputation systems – Community norms – Collective activities – Inter-community connections
Methods:
__init__ (Line 47)
def __init__(self, model_name):
"""No method docstring."""
Purpose: No method docstring.
Parameters:
– self: Instance reference
– model_name: LLM model to use (e.g., “gpt-4”)
add_member (Line 52)
def add_member(self, member):
"""Add member to the system."""
Purpose: Add member to the system.
Parameters:
– self: Instance reference
– member: Parameter for member
create_community (Line 57)
def create_community(self, name, focus, norms):
"""Create a new community."""
Purpose: Create a new community.
Parameters:
– self: Instance reference
– name: Identifier or label
– focus: Parameter for focus
– norms: Parameter for norms
join_community (Line 64)
def join_community(self, member_name, community_name):
"""Member joins a community."""
Purpose: Member joins a community.
Parameters:
– self: Instance reference
– member_name: Parameter for member_name
– community_name: Parameter for community_name
suggest_communities (Line 73)
def suggest_communities(self, member_name):
"""Suggest communities based on interests."""
Purpose: Suggest communities based on interests.
Parameters:
– self: Instance reference
– member_name: Parameter for member_name
contribute (Line 90)
def contribute(self, member_name, community_name, contribution):
"""Member contributes to community."""
Purpose: Member contributes to community.
Parameters:
– self: Instance reference
– member_name: Parameter for member_name
– community_name: Parameter for community_name
– contribution: Parameter for contribution
organize_event (Line 110)
def organize_event(self, community_name, event_description):
"""Community organizes an event."""
Purpose: Community organizes an event.
Parameters:
– self: Instance reference
– community_name: Parameter for community_name
– event_description: Parameter for event_description
get_top_contributors (Line 127)
def get_top_contributors(self, community_name, n):
"""Get top contributors in a community."""
Purpose: Get top contributors in a community.
Parameters:
– self: Instance reference
– community_name: Parameter for community_name
– n: Parameter for n
run (Line 141)
def run(self, scenario):
"""Execute community scenario."""
Purpose: Execute community scenario.
Parameters:
– self: Instance reference
– scenario: Parameter for scenario
Design Patterns Used
- Strategy Pattern: Different execution strategies for various scenarios
- State Pattern: Managing different states in the workflow
- Chain of Responsibility: Sequential processing through workflow nodes
- Observer Pattern: Tracking and monitoring pattern execution
- Factory Pattern: Creating instances with proper configuration
Usage Example
# Initialize the pattern
pattern = CommunityMember(name="example", model_name="gpt-4")
# Configure and execute
result = pattern.execute(data={"key": "value"})
# Check results
print(result)
Key Concepts
- LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
- Workflow Orchestration: LangGraph manages execution flow through nodes
- State Management: TypedDict defines workflow state structure
- Error Handling: Comprehensive error handling and fallback mechanisms
- Extensibility: Designed for easy customization and extension
Extension Points
This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities