FeedMiner

Universal saved content processor with multi-model AI analysis using Strands agents

FeedMiner is a serverless AWS application that processes exported saved content from social media platforms (Instagram, Twitter, Reddit, etc.) and provides AI-powered analysis for goal-setting and behavioral insights. The system now supports 6 AI models across 3 families (Anthropic Claude, Amazon Nova, Meta Llama) enabling users to compare different AI approaches and access cost-effective analysis options.

🔒 Security Audited: Repository has undergone comprehensive security review and is approved for public release with 95% confidence level. All sensitive data is properly managed through environment variables and secure deployment practices.

🏗 Architecture Overview

FeedMiner is built as a serverless application using AWS SAM (Serverless Application Model) with the following key components:

Core Infrastructure

AWS Lambda Functions: Serverless compute for all processing
Amazon API Gateway: REST and WebSocket APIs for client interaction
Amazon DynamoDB: NoSQL database for metadata and analysis storage
Amazon S3: Object storage for raw content and detailed analysis results
Amazon Bedrock: Multi-model AI access (Claude, Nova, Llama) for content analysis

AI Processing Engine (v0.4.0+)

Strands Agents Framework: Specialized AI agents with native multi-model support
6-Model Integration: 2 Claude + 2 Nova + 2 Llama models (100% success rate)
3-Family Support: Anthropic Claude, Amazon Nova, Meta Llama
Cost Optimization: Nova models provide 75% cost savings vs Claude
Performance Excellence: Llama models achieve 504-861ms response times
Educational Comparison: Compare responses across different AI company approaches
Structured Output: Pydantic models ensure consistent responses across all model families

🎯 Current Capabilities

✅ Implemented Features (Foundation Phase - v0.1.x)

Note: Currently transitioning from immediate goal recommendations to interactive conversational goal discovery system.

Content Upload & Storage
- REST API endpoint for uploading exported content
- Automatic S3 storage with unique content IDs
- DynamoDB metadata tracking with timestamps and status
Real-time Processing
- WebSocket API for streaming analysis updates
- Bidirectional communication for progress tracking
- Connection management with automatic cleanup
Multi-File Instagram Processing 🎨 PRODUCTION (v0.3.0)
- ZIP Upload Support: Complete Instagram export ZIP processing with 5 data types
- Smart Data Sampling: 100 items per category (500 total) for optimal analysis performance
- Comprehensive Analysis: Unified insights across saved_posts, liked_posts, comments, user_posts, following
- Interactive Data Selection: User-friendly category selection interface
- Production Deployment: Live multi-file processing pipeline in AWS
Data Retrieval
- REST API for listing all content
- Individual content retrieval with optional raw data
- Job status tracking for long-running processes
Professional React Frontend Application 🎨 LIVE (v0.1.4)
- Production Deployment: Live on AWS Amplify with GitHub CI/CD integration
- Portfolio-Ready Application: React 18 + TypeScript + Vite + Tailwind CSS
- Real Data Showcase: Interactive visualization of 177 Instagram posts analysis
- Goal Recommendations: Evidence-based 30/90/365-day plans with success probability
- Behavioral Insights: Charts showing learning style, motivation cycles, and interest distribution
- Full-Stack Integration: Connected to AWS backend APIs for real-time processing
- Comprehensive Testing: 140 tests covering components, services, integration, and accessibility (110 passing, 30 with known chart rendering issues)

✅ Latest Implementation (July 20 - v0.2.0)

Multi-Model AI Integration 🤖
- Anthropic Direct: Original implementation for rapid prototyping and development
- AWS Bedrock: Production-ready Claude 3.5 Sonnet via Bedrock for enterprise deployment
- Model Switching: Runtime provider selection between Anthropic and Bedrock
- Performance Comparison: Built-in latency, cost, and quality benchmarking
- Extensible Architecture: Ready for additional Bedrock models (GPT-4, Titan, etc.)
- Frontend Integration: User interface for real-time model provider selection
Interactive Conversational Goal Discovery 🎯
- Behavioral Analysis First: Deep analysis of user behavior patterns before goal setting
- Conversational Interface: AI-powered dialogue to understand user intentions and aspirations
- Individual Post Deep-Dive: Detailed analysis of specific saved posts for evidence-based insights
- Co-Creative Goal Setting: Collaborative goal formulation through guided conversation
- Iterative Refinement: Continuous conversation to refine and adjust goals based on user feedback
- Evidence-Based Recommendations: Goals grounded in actual user behavior and specific content
- Action Plan Development: Specific, measurable steps derived from user's content patterns

🔧 Technical Implementation Details

Lambda Functions Architecture

API Layer (src/api/)

upload.py: Handles content uploads, generates UUIDs, stores in S3/DynamoDB
list.py: Paginated content listing with user filtering
get.py: Individual content retrieval with raw data option
job_status.py: Processing job status tracking
strands_model_switching.py: NEW v0.4.0 - Strands-based model switching and comparison

WebSocket Layer (src/websocket/)

connect.py: Connection establishment with TTL-based cleanup
disconnect.py: Connection cleanup and resource management
default.py: Message routing and streaming response handling

AI Processing Layer (src/agents/)

content_analysis.py: Main orchestration agent for content type detection
instagram_parser.py: Specialized Instagram content analysis using Strands
summarization.py: Content summarization agent (skeleton)
extraction.py: Data extraction agent (skeleton)

Orchestration Layer (src/orchestrator/)

orchestrator.py: DynamoDB stream-triggered workflow coordination

Data Models & Schemas

Instagram Analysis Models (Pydantic)

class InstagramPost(BaseModel):
    post_id: str
    author: str
    caption: str
    media_type: str  # photo, video, carousel, reel
    saved_at: str
    hashtags: List[str]
    location: Optional[str]
    engagement: Optional[Dict[str, int]]

class ContentCategory(BaseModel):
    name: str  # Technology, Food, Travel, etc.
    confidence: float  # 0-1 confidence score
    reasoning: str  # AI explanation

class ContentInsight(BaseModel):
    type: str  # theme, trend, preference
    description: str
    evidence: List[str]
    relevance_score: float

class InstagramAnalysisResult(BaseModel):
    total_posts: int
    categories: List[ContentCategory]
    insights: List[ContentInsight]
    top_authors: List[Dict[str, Any]]
    date_range: Dict[str, str]
    summary: str

Database Schema

DynamoDB Tables

Content Table (feedminer-content-dev)
- Primary Key: contentId (String)
- GSI: UserTimeIndex (userId + createdAt)
- GSI: StatusIndex (status + createdAt)
- Attributes: type, userId, status, metadata, analysis, s3Key
Connections Table (feedminer-connections-dev)
- Primary Key: connectionId (String)
- GSI: UserIndex (userId)
- TTL: 2 hours automatic cleanup
- Attributes: userId, connectedAt, endpoint
Jobs Table (feedminer-jobs-dev)
- Primary Key: jobId (String)
- GSI: ContentIndex (contentId)
- GSI: StatusIndex (status)
- Attributes: contentId, status, result, timestamps

S3 Storage Structure

feedminer-content-dev-{account-id}/
├── uploads/
│   └── {content-id}.json          # Raw uploaded content
├── analysis/
│   └── {content-id}/
│       ├── instagram_analysis.json # Detailed AI analysis
│       └── summary.json           # Processing summary
└── exports/
    └── {content-id}/              # Generated exports

🚀 Deployment & Configuration

Prerequisites

AWS CLI configured with appropriate permissions
SAM CLI installed
Python 3.12+ with virtual environment
Anthropic API key OR AWS Bedrock access

Environment Setup

# Quick setup
./scripts/setup.sh
source feedminer-env/bin/activate

# Manual setup
python3 -m venv feedminer-env
source feedminer-env/bin/activate
pip install -r requirements.txt

# Build and validate
sam build
sam validate --lint

Deployment Options

Option 1: Quick Deployment (Recommended)

# With Anthropic API key
./scripts/deploy.sh dev sk-ant-your-key-here

# With Bedrock (recommended for AWS)
./scripts/deploy.sh dev

Option 2: Manual Deployment

# Anthropic API
sam deploy --parameter-overrides \
  EnableWebSocket=true \
  AnthropicApiKey=sk-ant-your-key-here

# Bedrock
sam deploy --parameter-overrides \
  EnableWebSocket=true \
  AnthropicApiKey=BEDROCK_WILL_OVERRIDE

Local Development

# For local testing (disables WebSocket to avoid SAM local issues)
sam local start-api --parameter-overrides EnableWebSocket=false

# Run test suites
python tests/test_api.py        # REST API tests
python tests/test_websocket.py  # WebSocket tests

# Or use the test runner
./scripts/run_tests.sh

🔧 Configuration Parameters

CloudFormation Parameters

Environment: Deployment stage (dev/staging/prod)
AnthropicApiKey: API key for Claude access
AllowedOrigins: CORS origins for WebSocket connections
EnableWebSocket: Conditional WebSocket deployment (for SAM local compatibility)

Environment Variables (Auto-configured)

ANTHROPIC_API_KEY: Claude API access
CONTENT_BUCKET: S3 bucket for content storage
WEBSOCKET_API_ENDPOINT: WebSocket endpoint URL
DYNAMODB_TABLE_PREFIX: Table naming prefix
CONTENT_TABLE, JOBS_TABLE, CONNECTIONS_TABLE: Table names

🧪 Testing & Validation

Test Scripts

REST API Testing (tests/test_api.py)

Content upload with sample Instagram data
Content listing and pagination
Individual content retrieval
Error handling validation

WebSocket Testing (tests/test_websocket.py)

Connection establishment
Message routing and responses
Streaming analysis simulation
Connection cleanup

Running Tests

# Run all tests
./scripts/run_tests.sh

# Run specific test types
./scripts/run_tests.sh api        # REST API only
./scripts/run_tests.sh websocket  # WebSocket only
./scripts/run_tests.sh pytest     # Pytest suite

Instagram Data Format Handling

FeedMiner supports both real Instagram export format and our enhanced processing format:

Real Instagram Export Format (from Instagram data download):

{
  "saved_saved_media": [
    {
      "title": "rishfits",
      "string_map_data": {
        "Saved on": {
          "href": "https://www.instagram.com/reel/DDXmi2qRUUD/",
          "timestamp": 1733969519
        }
      }
    }
  ]
}

FeedMiner Enhanced Format (after processing and goal analysis):

{
  "type": "instagram_saved",
  "user_id": "real_user",
  "metadata": {
    "exported_at": "2025-07-14T13:58:07Z",
    "total_items": 177,
    "analysis_focus": "goal_setting_and_motivation",
    "patterns_discovered": {
      "goal_indicators": [
        {
          "goal_area": "Physical Fitness",
          "evidence_strength": "High",
          "save_count": 12,
          "suggested_goals": ["Establish consistent workout routine"]
        }
      ]
    }
  },
  "content": {
    "saved_posts": [
      {
        "post_id": "DDXmi2qRUUD",
        "author": "rishfits",
        "caption": "Content from @rishfits - Fitness & Health Goals",
        "media_type": "reel",
        "saved_at": "2024-12-11T14:45:19Z",
        "interest_category": "🏋️ Fitness & Health Goals",
        "url": "https://www.instagram.com/reel/DDXmi2qRUUD/"
      }
    ]
  }
}

🤖 AI Processing Pipeline

Content Analysis Workflow

Upload Phase
- Content uploaded via REST API
- Stored in S3 with unique ID
- DynamoDB record created with status='uploaded'
Detection Phase
- S3 trigger activates content analysis agent
- Content type detected (instagram_saved, twitter_bookmarks, etc.)
- Status updated to 'processing'
Analysis Phase
- Specialized agent (Instagram Parser) processes content
- Claude 3.7 Sonnet analyzes posts for:
  - Content categories with confidence scores
  - User behavior patterns and preferences
  - Trending topics and themes
  - Author interaction patterns
Storage Phase
- Structured results stored in DynamoDB
- Detailed analysis saved to S3
- Status updated to 'analyzed'
- WebSocket notifications sent

Instagram Goal-Oriented Analysis Features

Real Data Format Support

Native Instagram export format (saved_saved_media structure)
Automatic transformation to enhanced analysis format
Preserves all temporal and behavioral data from exports

Goal Area Detection (Validated with Real Data)

🏋️ Fitness & Health Goals: Workout routines, strength training, wellness
📚 Learning & Skill Development: Courses, tutorials, educational content
💼 Business & Entrepreneurship: Personal branding, startup content, professional development
🎨 Creative & Artistic Pursuits: Music, art, design, creative expression
💻 Technology & Innovation: Tech tools, digital innovation, coding content

Behavioral Insight Extraction

Content Preference Analysis: Reels vs Posts preference (learning style indicator)
Temporal Pattern Recognition: Peak motivation periods, consistency indicators
Interest Distribution Mapping: Quantified interest percentages for goal prioritization
Author Influence Analysis: Most-saved creators indicating deep interest areas
Goal Evidence Strength: High/Medium/Low confidence scoring for goal recommendations

Actionable Output

Specific Goal Recommendations: Concrete, measurable goals aligned with interests
Timeframe Planning: 30-day, 90-day, and 1-year goal roadmaps
Behavioral Insights: Learning style preferences and motivation patterns
Interest Categories: Quantified distribution of attention and motivation

Output Format

{
  "total_posts": 25,
  "categories": [
    {
      "name": "Technology",
      "confidence": 0.85,
      "reasoning": "High frequency of AI and programming hashtags"
    }
  ],
  "insights": [
    {
      "type": "preference",
      "description": "Strong interest in AI/ML content",
      "evidence": ["15 AI-related posts", "Follows tech influencers"],
      "relevance_score": 0.9
    }
  ],
  "top_authors": [
    {"author": "ai_research_hub", "post_count": 8}
  ],
  "summary": "User shows strong technical interests..."
}

🔍 API Reference

REST Endpoints

Base URL: https://wqtfb6rv15.execute-api.us-west-2.amazonaws.com/dev

Upload Content

POST /upload
Content-Type: application/json

{
  "type": "instagram_saved",
  "user_id": "user123",
  "content": { ... }
}

Response:
{
  "contentId": "uuid",
  "message": "Content uploaded successfully",
  "s3Key": "uploads/uuid.json"
}

List Content

GET /content?userId=user123&limit=20

Response:
{
  "items": [...],
  "count": 10,
  "hasMore": false
}

Get Content

GET /content/{contentId}?includeRaw=true

Response:
{
  "contentId": "uuid",
  "type": "instagram_saved",
  "status": "analyzed",
  "analysis": { ... },
  "rawContent": { ... }  // if includeRaw=true
}

WebSocket API

URL: wss://yzzspgrevg.execute-api.us-west-2.amazonaws.com/dev

Connection

Automatic connection tracking in DynamoDB
2-hour TTL for cleanup
Connection ID returned in responses

Message Format

// Client to Server
{
  "action": "analyze_content",
  "content_id": "uuid",
  "data": { ... }
}

// Server to Client
{
  "type": "analysis_progress",
  "message": "Analyzing content categories...",
  "progress": 0.5,
  "connection_id": "abc123"
}

🛠 Development Patterns & Best Practices

Code Organization

feedminer/
├── src/
│   ├── api/           # REST endpoint handlers
│   ├── websocket/     # WebSocket handlers
│   ├── agents/        # AI processing agents
│   └── orchestrator/  # Workflow coordination
├── tests/             # Unit and integration tests
│   ├── data/         # Test data and fixtures
│   ├── test_api.py   # REST API tests
│   └── test_websocket.py # WebSocket tests
├── scripts/           # Development and deployment scripts
│   ├── setup.sh      # Environment setup
│   ├── deploy.sh     # Deployment automation
│   └── run_tests.sh  # Test runner
├── docs/              # Additional documentation
│   ├── API.md        # API reference
│   └── DEPLOYMENT.md # Deployment guide
├── template.yaml      # SAM CloudFormation template
├── requirements.txt     # All dependencies
├── CHANGELOG.md       # Version history
└── README.md         # This documentation

Error Handling Patterns

Lambda Functions

Consistent error response format
Detailed logging for debugging
Graceful degradation for non-critical failures

DynamoDB Operations

Decimal serialization handling (DecimalEncoder)
Conditional updates for data consistency
GSI query optimization

S3 Operations

Pre-signed URL generation for large uploads
Versioning for content history
Lifecycle policies for cost optimization

Security Considerations

API Security

CORS configuration for web access
IAM role-based access control
API Gateway throttling (100 req/sec, 200 burst)

Data Protection

S3 bucket policies (private by default)
DynamoDB encryption at rest
Lambda environment variable encryption

Network Security

VPC configuration ready (currently public for simplicity)
CloudFront integration ready
WAF integration ready

🚀 Development Status

Current Version: v0.4.1 (Production Enhancements & Project Organization)
Status: Production-deployed full-stack application with 6 AI models across 3 families

Recent Accomplishments

✅ Multi-file Instagram ZIP processing (v0.3.0)
✅ Multi-provider AI integration with runtime switching
✅ Production React frontend with real data visualization
✅ Comprehensive security audit (95% confidence - public ready)
✅ Professional documentation and testing framework

🚧 Known Issues & Solutions

Resolved Issues

SAM Local WebSocket Support
- Issue: SAM local doesn't support WebSocket APIs
- Solution: Conditional WebSocket deployment via EnableWebSocket parameter
- Usage: Set EnableWebSocket=false for local development
DynamoDB Decimal Serialization
- Issue: JSON serialization error with DynamoDB Decimal types
- Solution: Custom DecimalEncoder class in API handlers
- Implementation: Applied to all API response handlers
Route Key Parsing
- Issue: SAM trying to parse WebSocket routes as HTTP routes
- Solution: Quoted route keys ("$connect" vs $connect)
- Result: Proper WebSocket route handling

Current Limitations

Content Type Support
- Only Instagram analysis fully implemented
- Twitter, Reddit agents are skeleton implementations
- Expansion Path: Copy Instagram pattern for new platforms
Scalability Considerations
- Single-region deployment
- No auto-scaling configuration yet
- Future: Multi-region, auto-scaling groups
Monitoring & Observability
- Basic CloudWatch logging
- No custom metrics or dashboards
- Future: X-Ray tracing, custom CloudWatch dashboards

🎯 Updated Roadmap & Development Timeline

Phase 1a: Infrastructure Deployment (✅ Complete - July 13)

AWS SAM infrastructure setup and deployment
REST API with CRUD operations
WebSocket real-time communication
Basic Instagram JSON processing
Comprehensive testing and automation
Project organization and documentation

Phase 1b: Real Data Testing (✅ Complete - July 14-15)

Test with actual Instagram export data (177 real Instagram posts processed)
Validate JSON parsing and error handling (Enhanced data transformer created)
Performance baseline measurements (Session duration: ~2 hours)
User experience optimization (Goal-oriented analysis framework developed)

Phase 1c: Multi-Model AI Integration (✅ Complete - v0.2.0)

Bedrock integration implementation
Model performance comparison (Anthropic API vs Bedrock)
Strands model-swapping demonstration
Cost and latency analysis
Frontend model selection UI

Phase 2: Enhanced Instagram Data Support (✅ Complete - v0.3.0)

Multi-File Instagram Processing: Complete Instagram export ZIP file support
Hierarchical Data Analysis: Saved posts, likes, comments, and user content correlation
Advanced Storage Architecture: S3 hierarchical organization for complex Instagram exports
Comprehensive Behavioral Analysis: Cross-activity pattern discovery and temporal insights
Enhanced AI Analysis: Multi-source Instagram intelligence for deeper goal recommendations
Production Deployment: Live multi-file processing pipeline with smart sampling (100 items per category)
See Documentation: Multi-File Instagram Data Processing Plan

Phase 3: Platform Expansion (📋 Planned)

Twitter/X bookmarks analysis
Reddit saved posts analysis
Cross-platform content correlation
Web dashboard for visualization

Phase 4: Enterprise Features (💭 Future)

Multi-region deployment
Advanced analytics and reporting
User authentication and multi-tenancy
Custom AI model fine-tuning

🤝 Integration Points

External System Integration

Data Sources

Instagram data export (JSON format)
Twitter/X bookmark exports (future)
Reddit saved posts (future)
Generic JSON content (extensible)

Output Formats

REST API JSON responses
WebSocket streaming updates
S3 stored analysis results
DynamoDB queryable metadata

📊 Performance & Scaling

Current Performance Characteristics

API Response Times

Upload: ~500ms (including S3 storage)
List: ~200ms (DynamoDB query)
Get: ~300ms (DynamoDB + conditional S3)
WebSocket: ~100ms connection establishment

Processing Times

Instagram analysis: ~10-30 seconds (depends on content size)
Category detection: ~5-10 seconds
Insight extraction: ~15-25 seconds

Scalability Limits (Current)

Concurrent Lambda executions: 1000 (AWS default)
DynamoDB read/write capacity: Pay-per-request (auto-scaling)
S3 requests: Virtually unlimited
WebSocket connections: 3000 concurrent (API Gateway default)

Optimization Opportunities

Caching Strategy
- ElastiCache for frequent queries
- CloudFront for static content
- Application-level result caching
Batch Processing
- SQS for async processing queues
- Step Functions for complex workflows
- Batch Lambda for large datasets
Database Optimization
- DynamoDB GSI optimization
- Partition key distribution analysis
- Read replica strategies

📞 Support & Troubleshooting

Common Issues

Deployment Failures

# Validate template
sam validate --lint

# Check build output
sam build --debug

# Verify AWS credentials
aws sts get-caller-identity

API Errors

# Check CloudWatch logs
aws logs filter-log-events \
  --log-group-name "/aws/lambda/feedminer-content-upload-dev" \
  --start-time $(date -d '1 hour ago' +%s)000

WebSocket Issues

# Test connection manually
wscat -c wss://yzzspgrevg.execute-api.us-west-2.amazonaws.com/dev

# Check connection table
aws dynamodb scan --table-name feedminer-connections-dev

Debug Commands

SAM Local Testing

# Start API locally (without WebSocket)
sam local start-api --parameter-overrides EnableWebSocket=false

# Invoke specific function
sam local invoke ContentUploadFunction --event test-events/upload.json

# Generate test events
sam local generate-event apigateway aws-proxy > test-event.json

AWS Resource Inspection

# List stack resources
aws cloudformation describe-stack-resources --stack-name feedminer

# Check Lambda function logs
aws logs tail /aws/lambda/feedminer-content-analysis-dev --follow

# Query DynamoDB
aws dynamodb scan --table-name feedminer-content-dev --max-items 5

Development Tips

Iterative Development
- Use sam build && sam deploy for rapid iteration
- Test locally with sam local start-api when possible
- Use --no-confirm-changeset for automated deployments
Debugging Strategy
- Add extensive logging in Lambda functions
- Use CloudWatch Insights for log analysis
- Implement structured logging with JSON format
Testing Strategy
- Run test scripts after each deployment
- Use different environments (dev/staging/prod)
- Implement integration tests for critical paths

🔧 Quick Development Commands

Backend (AWS Infrastructure)

# Environment setup
./scripts/setup.sh
source feedminer-env/bin/activate

# Quick deployment
./scripts/deploy.sh dev sk-ant-your-key-here

# Run all tests
./scripts/run_tests.sh

# Manual commands
sam build && sam deploy --no-confirm-changeset --parameter-overrides EnableWebSocket=true AnthropicApiKey=your-key
python tests/test_api.py
python tests/test_websocket.py

# Check logs
aws logs tail /aws/lambda/feedminer-content-upload-dev --follow

# Local development
sam local start-api --parameter-overrides EnableWebSocket=false

Frontend Demo (React Application)

# Navigate to frontend demo
cd frontend-demo

# Install dependencies
npm install

# Start development server
npm run dev
# View at http://localhost:5173

# Build for production
npm run build

# Preview production build
npm run preview

# Run comprehensive test suite
npm run test

# Run tests with coverage
npm run test:coverage

🚀 Live Deployment (AWS Amplify)

Production Frontend: Successfully deployed via AWS Amplify with GitHub integration

Deployment: Automated builds from GitHub repository
CI/CD: Continuous deployment on push to main branch
Integration: Connected to backend AWS APIs for real-time data processing
Status: ✅ Production-ready with real Instagram data analysis capabilities

Generated with Claude Code 🤖
Last Updated: August 16, 2025
Version: 0.4.1 (Production Enhancements & Project Organization)
System Status: 🚀 Live Production Full-Stack Application - 6 AI Models (Claude + Nova + Llama) + Multi-Family Comparison

Name		Name	Last commit message	Last commit date
Latest commit History 67 Commits
docs		docs
frontend-demo		frontend-demo
layers/ai-providers		layers/ai-providers
scripts		scripts
src		src
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
amplify.yml		amplify.yml
pytest.ini		pytest.ini
requirements.txt		requirements.txt
template.yaml		template.yaml

License

dimafarer/feedminer

Folders and files

Latest commit

History

Repository files navigation