Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,178 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# outputs
+output/*
+investigators/output/*

README.md

@@ -1,12 +1,7 @@
 ---
-title: OSINT Investigator
-emoji: 🌍
-colorFrom: indigo
-colorTo: red
+title: OSINT_Investigator
+app_file: app.py
 sdk: gradio
 sdk_version: 5.30.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OSINT_Agent

app.py

@@ -0,0 +1,30 @@
+import gradio as gr
+from investigators.src.investigators.crew import Investigators
+
+def investigate(target_name, affiliations):
+    inputs = {
+        'target': target_name,
+        'affiliations': affiliations,
+    # 'current_year': str(datetime.now().year)
+    }
+
+    try:
+        crew_output = Investigators().crew().kickoff(inputs=inputs)
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew: {e}")
+    
+    return crew_output.raw
+
+view = gr.Interface(
+    fn=investigate,
+    inputs=[
+        gr.Textbox(label="Target name:"),
+        gr.Textbox(label="Target Affiliations (comma separated):")],
+    outputs=[gr.Markdown(label="Risk Assessment Report:")],
+    flagging_mode="never",
+    examples=[
+        ["Raz Nissim", "Ben Gurion University, General Motors"],
+    ],
+    title="OSINT Investigator",
+    description="Enter the name of your target and their affiliations (to make search easier), and get a AML Risk assessment based on their public information.",)
+view.launch(inbrowser=True)

investigators/.gitignore

@@ -0,0 +1,3 @@
+.env
+__pycache__/
+.DS_Store

investigators/README.md

@@ -0,0 +1,54 @@
+# Investigators Crew
+
+Welcome to the Investigators Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <3.13 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install uv:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+(Optional) Lock the dependencies and install them by using the CLI command:
+```bash
+crewai install
+```
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/investigators/config/agents.yaml` to define your agents
+- Modify `src/investigators/config/tasks.yaml` to define your tasks
+- Modify `src/investigators/crew.py` to add your own logic, tools and specific args
+- Modify `src/investigators/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your crew of AI agents and begin task execution, run this from the root folder of your project:
+
+```bash
+$ crewai run
+```
+
+This command initializes the investigators Crew, assembling the agents and assigning them tasks as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The investigators Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding the Investigators Crew or crewAI.
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

investigators/knowledge/user_preference.txt

@@ -0,0 +1,4 @@
+User name is John Doe.
+User is an AI Engineer.
+User is interested in AI Agents.
+User is based in San Francisco, California.

investigators/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "investigators"
+version = "0.1.0"
+description = "investigators using crewAI"
+authors = [{ name = "Raz Nissim", email = "[email protected]" }]
+requires-python = ">=3.10,<3.13"
+dependencies = [
+    "crewai[tools]>=0.119.0,<1.0.0"
+]
+
+[project.scripts]
+investigators = "investigators.main:run"
+run_crew = "investigators.main:run"
+train = "investigators.main:train"
+replay = "investigators.main:replay"
+test = "investigators.main:test"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.crewai]
+type = "crew"

investigators/src/investigators/config/agents.yaml

@@ -0,0 +1,34 @@
+researcher:
+  role: >
+    Research Specialist
+  goal: >
+    Gather comprehensive information from public sources about the target: {target}, that has the following affiliations: {affiliations}. 
+  backstory: >
+    You are an expert OSINT researcher with deep experience in 
+    finding and connecting information about people and businesses. You know how to
+    follow information trails and identify valuable data sources.
+  llm: openai/gpt-4o-mini
+
+fincrime_analyst:
+  role: >
+    Financial Crime Analyst
+  goal: >
+    Analyze gathered information on {target} to identify potential money laundering indicators. 
+    Focus on the person and not their affiliations. 
+    Ignore any sources that are not relevant, especially if do not contain the full name of the target ({target}).
+  backstory: >
+    You are a seasoned financial crime expert with extensive knowledge
+    of money laundering techniques, red flags, and detection methods. You can spot
+    suspicious patterns that others might miss.
+  llm: openai/gpt-4o-mini
+
+osint_reporter:
+  role: >
+    Intelligence Reporter
+  goal: >
+    Create clear, structured reports from analysis findings.
+  backstory: >
+    You are a skilled intelligence reporter who can transform complex
+    findings into clear, actionable reports. You know how to present information
+    in a way that highlights the most important elements.
+  llm: openai/gpt-4o-mini

investigators/src/investigators/config/tasks.yaml

@@ -0,0 +1,85 @@
+research_target:
+  description: >
+    Research {target} ({affiliations}) thoroughly using available search tools:
+    
+    Name: {target}
+    
+    Your research should focus on:
+    1. Basic background information
+    2. Professional history and business activities
+    3. Corporate structures and relationships
+    4. Public records and news mentions
+    5. Legal or regulatory issues
+    6. Unusual business patterns or inconsistencies
+    
+    Organize your findings clearly and be sure to track your sources.
+  expected_output: >
+    Comprehensive research findings on {target}
+  agent: researcher
+
+analyze_target:
+  description: >
+    Analyze the research findings on {target} to identify potential money laundering red flags. Focus only on {target} and not their affiliations. 
+    Ignore any sources that do not contain the full name of the target ({target}) at least once.
+
+    If relevant, analyze for the following reputational Red Flags:
+       - Negative news coverage related to financial crimes
+       - Past investigations or regulatory actions
+       - Association with politically exposed persons (PEPs)
+    
+    For each identified red flag, provide:
+    - A clear description
+    - Severity assessment (on a scale of 0.0 to 1.0)
+    - Supporting evidence
+    - Your reasoning
+    - Sources of information
+    
+    Structure your output in JSON format.
+    IMPORTANT: Output ONLY the raw JSON any markdown formatting, code block delimiters, or backticks.
+  expected_output: >
+    JSON-structured analysis of {target}'s potential money laundering red flags
+  agent: fincrime_analyst
+  context:
+    - research_target
+  output_file: output/analysis_output_{target}.json
+
+
+reporting_task:
+  description: >
+    Create a comprehensive intelligence report based on the following analysis
+    of potential money laundering red flags:
+    
+    Target Name: {target}
+    
+    Your report should include:
+    
+    1. Executive Summary
+       - Brief overview of the target
+       - Summary of key findings and risk assessment
+    
+    2. Target Profile
+       - Background information
+       - Known associates and relationships
+       - Business activities and corporate structure (if applicable)
+    
+    3. Red Flag Analysis
+       - Detailed examination of each identified red flag
+       - Supporting evidence and reasoning
+       - Risk severity assessment
+    
+    4. Overall Risk Assessment
+       - Holistic evaluation of money laundering risk
+       - Confidence level in findings
+       - Potential alternative explanations
+    
+    5. Recommendations
+       - Suggested next steps for investigation
+       - Additional intelligence gaps to address
+    
+    Format the report in a clear, professional structure with sections and subsections.
+  expected_output: >
+    Comprehensive intelligence report on money laundering risks, in Markdown.
+  agent: osint_reporter
+  context:
+    - analyze_target
+  output_file: output/osint_report_{target}.md

investigators/src/investigators/crew.py

@@ -0,0 +1,68 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai_tools import SerperDevTool
+
+
+
+@CrewBase
+class Investigators():
+    """Investigators crew"""
+
+    #Agents
+    agents_config = 'config/agents.yaml'
+    
+    @agent
+    def researcher(self) -> Agent:
+        return Agent(
+            config=self.agents_config['researcher'],
+            verbose=True,
+            tools=[SerperDevTool()],
+            retry_on_fail=True,  # Enable retry
+            max_retries=3  # Set maximum retries
+        )
+
+    @agent
+    def fincrime_analyst(self) -> Agent:
+        return Agent(
+            config=self.agents_config['fincrime_analyst'],
+            verbose=False,
+        )
+    
+    @agent
+    def osint_reporter(self) -> Agent:
+        return Agent(
+            config=self.agents_config['osint_reporter'],
+            verbose=False,
+        )
+
+    # Tasks
+    tasks_config = 'config/tasks.yaml'
+
+    @task
+    def research_target(self) -> Task:
+        return Task(
+            config=self.tasks_config['research_target'],
+        )
+
+    @task
+    def analyze_target(self) -> Task:
+        return Task(
+            config=self.tasks_config['analyze_target'], 
+        )
+    
+    @task
+    def reporting_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['reporting_task'], 
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Investigators crew"""
+
+        return Crew(
+            agents=self.agents, # Automatically created by the @agent decorator
+            tasks=self.tasks, # Automatically created by the @task decorator
+            process=Process.sequential,
+            verbose=True,
+        )

investigators/src/investigators/main.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+import os
+import sys
+import warnings
+
+from datetime import datetime
+
+from investigators.crew import Investigators
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+# Create output directory if it doesn't exist
+os.makedirs('output', exist_ok=True)
+
+def run():
+    """
+    Run the crew.
+    """
+    # inputs = {
+    #     'target': 'Raz Nissim',
+    #     'affiliations': 'Ben Gurion University, General Motors',
+    #     # 'current_year': str(datetime.now().year)
+    # }
+
+    # inputs = {
+    #     'target': 'Avraham Hirschson',
+    #     'affiliations': 'Israeli government, Israeli Knesset, Histadrut',
+    #     # 'current_year': str(datetime.now().year)
+    # }
+
+    # inputs = {
+    #     'target': 'Igal Nissim',
+    #     'affiliations': 'Comverse, Verint',
+    #     # 'current_year': str(datetime.now().year)
+    # }
+
+    # inputs = {
+    #     'target': 'Yeela Harel',
+    #     'affiliations': 'Israel Ministry of Justice, ThetaRay, Bank Of Israel',
+    #     # 'current_year': str(datetime.now().year)
+    # }
+
+    # inputs = {
+    #     'target': 'Yehuda Harel',
+    #     'affiliations': 'Hapoalim Bank',
+    #     # 'current_year': str(datetime.now().year)
+    # }
+
+    inputs = {
+        'target': 'Bar Mittelman',
+        'affiliations': 'Bitin, crypto',
+        # 'current_year': str(datetime.now().year)
+    }
+
+    try:
+        Investigators().crew().kickoff(inputs=inputs)
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew: {e}")
+
+

investigators/src/investigators/tools/custom_tool.py

@@ -0,0 +1,19 @@
+from crewai.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "OSINT_Agent"
+version = "0.1.0"
+description = "Tool for AI-based investigations and KYC"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gradio>=5.22.0",
+    "openai>=1.68.2",
+    "openai-agents>=0.0.6",
+    "python-dotenv>=1.0.1",
+    "crewai[tools]>=0.119.0,<1.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.29.5",
+]

requirements-doc.md

@@ -0,0 +1,313 @@
+# OSINT Money Laundering Detection Application
+## Requirements and Implementation Plan
+
+## 1. Executive Summary
+
+This document outlines the requirements and implementation plan for an Open Source Intelligence (OSINT) application designed to identify potential money laundering red flags associated with individuals and businesses. The application will leverage CrewAI as the agent orchestration framework, Brave MCP for web searches, and frontier Large Language Models (LLMs) for information analysis and structured output generation. The user interface will be built using Gradio.
+
+## 2. Project Goals
+
+- Create an OSINT tool that gathers comprehensive information about individuals and businesses from publicly available sources
+- Identify potential money laundering indicators based on analysis of the gathered information
+- Present findings in a structured, actionable format to assist in financial crime investigations
+- Provide an intuitive user interface that allows for easy input and clear presentation of results
+
+## 3. Technical Architecture
+
+### 3.1 Core Components
+
+1. **CrewAI Framework**: Orchestrates autonomous agents to perform specialized tasks
+2. **Web Search Module**: Utilizes Brave MCP for comprehensive web searches
+3. **LLM Analysis Engine**: Leverages frontier LLMs to process and analyze gathered information
+4. **Gradio Frontend**: Provides the user interface for interaction with the system
+
+### 3.2 Architecture Diagram
+
+```
+┌───────────────────┐          ┌──────────────────────┐
+│                   │          │                      │
+│  Gradio Frontend  │◄────────►│  CrewAI Controller   │
+│                   │          │                      │
+└───────────────────┘          └──────────┬───────────┘
+                                          │
+                                          ▼
+                    ┌──────────────────────────────────────┐
+                    │                                      │
+                    │      Agent Orchestration Layer       │
+                    │                                      │
+                    └───┬─────────────┬─────────────┬──────┘
+                        │             │             │
+            ┌───────────▼───┐ ┌───────▼───────┐ ┌───▼────────────┐
+            │               │ │               │ │                │
+            │ Search Agent  │ │ Analysis Agent│ │ Reporting Agent│
+            │ (Brave MCP)   │ │ (LLM)         │ │ (LLM)          │
+            │               │ │               │ │                │
+            └───────────────┘ └───────────────┘ └────────────────┘
+```
+
+## 4. Detailed Requirements
+
+### 4.1 Data Collection Requirements
+
+#### 4.1.1 Target Entities
+- Individual profile information
+  - Personal identifiers (name, age, location)
+  - Professional history
+  - Social media presence
+  - Public records (property ownership, legal filings)
+- Business profile information
+  - Corporate structure
+  - Ownership information
+  - Business registration details
+  - Financial disclosures if publicly available
+  - Business relationships and partnerships
+  - Industry reputation
+
+#### 4.1.2 Search Parameters
+- Primary identifiers (full name, business name)
+- Secondary identifiers (location, industry, associates)
+- Customizable search depth (standard, deep)
+- Date range filtering capabilities
+- Geographic focus areas
+
+### 4.2 Analysis Requirements
+
+#### 4.2.1 Money Laundering Indicators
+The system should detect and flag the following potential indicators:
+
+- **Structural Red Flags**
+  - Complex corporate structures with no clear business purpose
+  - Companies registered in high-risk jurisdictions
+  - Shell companies with minimal operational footprint
+  - Frequent changes in business structure or ownership
+
+- **Transactional Red Flags**
+  - Inconsistencies between public business activity and apparent resources
+  - Involvement with industries known for money laundering risks
+  - Connections to entities on sanction lists or watchlists
+  - Unusual growth patterns or business expansions
+
+- **Reputational Red Flags**
+  - Negative news coverage related to financial crimes
+  - Past investigations or regulatory actions
+  - Association with politically exposed persons (PEPs)
+  - Inconsistencies in public statements and actual business operations
+
+#### 4.2.2 LLM Analysis Capabilities
+- Extract and correlate information from diverse sources
+- Identify patterns and anomalies in collected data
+- Apply AML (Anti-Money Laundering) expertise to evaluate findings
+- Generate confidence scores for identified red flags
+- Explain reasoning behind flagged items
+
+### 4.3 User Interface Requirements
+
+#### 4.3.1 Input Interface
+- Target entity input fields (individual name, business name)
+- Search parameter configuration options
+- Investigation depth selector
+- Search history functionality
+
+#### 4.3.2 Results Display
+- Summary dashboard with key findings
+- Detailed report section with evidence
+- Visualization of entity relationships
+- Red flag severity indicators
+- Source citations for all information
+- Option to export findings in various formats (PDF, CSV, JSON)
+
+#### 4.3.3 User Experience
+- Progress indicators during search and analysis
+- Responsive design for desktop and tablet use
+- Clear navigation between different report sections
+- Ability to save and reload previous investigations
+
+## 5. Agent Structure (CrewAI Implementation)
+
+### 5.1 Agent Roles and Responsibilities
+
+#### 5.1.1 Research Agent
+- **Objective**: Gather comprehensive information about target entities
+- **Tools**: Brave MCP search API
+- **Capabilities**:
+  - Execute multi-faceted search queries
+  - Follow information trails across multiple sources
+  - Filter and prioritize relevant information
+  - Store and organize gathered data
+
+#### 5.1.2 Analysis Agent
+- **Objective**: Process gathered information to identify potential money laundering indicators
+- **Tools**: Frontier LLM API
+- **Capabilities**:
+  - Apply AML expertise to evaluate gathered information
+  - Cross-reference findings against known money laundering patterns
+  - Identify and categorize potential red flags
+  - Assign confidence scores to findings
+
+#### 5.1.3 Reporting Agent
+- **Objective**: Create structured, clear reports from analysis findings
+- **Tools**: Frontier LLM API
+- **Capabilities**:
+  - Organize findings in a logical structure
+  - Generate concise summaries of complex information
+  - Create visualizations of entity relationships
+  - Format reports for readability and impact
+
+### 5.2 Agent Communication Workflow
+
+1. User initiates search through Gradio interface
+2. Research Agent conducts initial search based on provided parameters
+3. Research Agent iteratively refines search based on initial findings
+4. Analysis Agent processes gathered information from Research Agent
+5. Analysis Agent identifies potential red flags and areas of concern
+6. Reporting Agent structures findings into comprehensive report
+7. Gradio interface displays final report to user
+
+## 6. Implementation Plan
+
+### 6.1 Phase 1: Core Framework Setup (Weeks 1-2)
+- Set up development environment
+- Implement basic CrewAI framework configuration
+- Create agent templates and communication protocols
+- Establish Brave MCP integration for basic searches
+- Implement LLM API connections
+
+### 6.2 Phase 2: Agent Development (Weeks 3-5)
+- Develop and test Research Agent capabilities
+- Implement Analysis Agent with basic AML pattern recognition
+- Create Reporting Agent with standard report templates
+- Test agent communication and data handoffs
+
+### 6.3 Phase 3: Frontend Development (Weeks 6-7)
+- Design and implement Gradio interface
+- Create input forms and configuration options
+- Develop results display components
+- Implement export functionality
+
+### 6.4 Phase 4: Integration and Testing (Weeks 8-9)
+- Integrate all components into unified system
+- Conduct performance testing
+- Optimize search algorithms and analysis pipelines
+- Perform security review
+
+### 6.5 Phase 5: Refinement and Launch (Weeks 10-12)
+- Conduct user acceptance testing
+- Refine UI/UX based on feedback
+- Optimize LLM prompts for improved analysis
+- Prepare documentation and launch materials
+
+## 7. Technical Requirements
+
+### 7.1 Development Requirements
+- Python 3.9+ environment
+- CrewAI framework (latest version)
+- Brave MCP API access credentials
+- Access to frontier LLM APIs (Claude, GPT-4, etc.)
+- Gradio UI framework
+
+### 7.2 Deployment Requirements
+- Server environment with Python support
+- Minimum 8GB RAM, 4 CPU cores recommended
+- API key management system
+- Secure credential storage
+- Rate limiting implementation for API calls
+
+### 7.3 Security Requirements
+- Encrypted storage of search results
+- Secure API key management
+- User authentication for accessing the application
+- Audit logging of all searches conducted
+- Compliance with relevant data protection regulations
+
+## 8. Evaluation Metrics
+
+### 8.1 Performance Metrics
+- Search completion time
+- Analysis accuracy (compared to expert review)
+- System resource utilization
+- API cost efficiency
+
+### 8.2 Quality Metrics
+- Red flag detection accuracy
+- False positive rate
+- Source diversity
+- Explanation quality for identified red flags
+
+## 9. Limitations and Ethical Considerations
+
+### 9.1 Technical Limitations
+- Reliance on publicly available information only
+- API rate limits may affect search depth
+- LLM hallucination risks require human verification
+- Limited to text-based information analysis
+
+### 9.2 Ethical Guidelines
+- System should be used as an investigative aid, not as sole decision basis
+- All findings require human verification before action
+- Use limited to legitimate AML and financial crime prevention purposes
+- Compliance with privacy laws and regulations required
+- Application should not be used for harassment or unauthorized surveillance
+
+## 10. Code Structure Overview
+
+### 10.1 Main Components
+
+```python
+# Project structure
+osint_aml_app/
+├── app.py                      # Main application entry point
+├── config/                     # Configuration files
+│   ├── config.yaml             # General configuration
+│   └── agent_configs.yaml      # Agent-specific configurations
+├── agents/                     # CrewAI agent implementations
+│   ├── research_agent.py       # Web search agent
+│   ├── analysis_agent.py       # AML analysis agent
+│   └── reporting_agent.py      # Report generation agent
+├── tools/                      # Tool implementations
+│   ├── brave_search.py         # Brave MCP search integration
+│   ├── llm_interface.py        # LLM API interfaces
+│   └── data_processor.py       # Data processing utilities
+├── ui/                         # Gradio UI components
+│   ├── input_forms.py          # Input interfaces
+│   ├── results_display.py      # Results visualization
+│   └── export_tools.py         # Report export functionality
+├── models/                     # Data models
+│   ├── entity.py               # Entity representation
+│   ├── red_flag.py             # Red flag classification
+│   └── report.py               # Report structure
+└── utils/                      # Utility functions
+    ├── validators.py           # Input validation
+    ├── parsers.py              # Content parsing
+    └── security.py             # Security utilities
+```
+
+## 11. Budget and Resource Requirements
+
+### 11.1 Development Resources
+- Developer time: 12 weeks (1-2 developers)
+- LLM API costs: Estimated $500-1000 for development and testing
+- Brave MCP API costs: Based on search volume (approximately $200-500)
+- Infrastructure costs: $100-200/month for development servers
+
+### 11.2 Operational Resources
+- Ongoing API costs: Dependent on usage volume
+- Maintenance: 10-15 hours per month
+- Infrastructure: $200-400/month depending on scale
+
+## 12. Expansion Possibilities
+
+- Integration with financial database APIs
+- Addition of document analysis capabilities
+- Implementation of temporal analysis (tracking changes over time)
+- Development of collaborative investigation features
+- Integration with case management systems
+- Support for additional languages and jurisdictions
+
+## 13. Success Criteria
+
+The application will be considered successful if it:
+- Accurately identifies at least 85% of known money laundering indicators in test cases
+- Maintains a false positive rate below 15%
+- Completes standard searches in under 5 minutes
+- Receives positive usability feedback from AML professionals
+- Provides clear, actionable intelligence that enhances investigation capabilities

requirements.txt

@@ -0,0 +1,9 @@
+crewai==0.120.1
+crewai-tools==0.45.0
+gradio==5.30.0
+gradio-client==1.10.1
+litellm==1.68.0
+markdown-it-py==3.0.0
+openai==1.75.0
+openai-agents==0.0.12
+uv==0.7.6

test_serper.py

@@ -0,0 +1,20 @@
+import os
+import requests
+
+# Test your API key with a simple request
+serper_api_key = os.getenv("SERPER_API_KEY")  # Or however you're storing it
+
+headers = {
+    "X-API-KEY": serper_api_key,
+    "Content-Type": "application/json"
+}
+
+payload = {
+    "q": "test query",
+    "gl": "us",
+    "hl": "en"
+}
+
+response = requests.post("https://google.serper.dev/search", headers=headers, json=payload)
+print(f"Status code: {response.status_code}")
+print(f"Response: {response.text}")