diff --git a/agents/30-days-of-agents/context-engineering.mdx b/agents/30-days-of-agents/context-engineering.mdx new file mode 100644 index 00000000..e3b3fa30 --- /dev/null +++ b/agents/30-days-of-agents/context-engineering.mdx @@ -0,0 +1,185 @@ +--- +title: "Week 4: Context Engineering - Building Intelligent Information Systems" +sidebarTitle: "Context Engineering" +description: + "Master the art of context engineering - building dynamic systems that provide + the right information and tools in the right format to enable agents to + accomplish complex tasks effectively." +--- + +![Agents Bootcamp: Context Engineering - Week 4](/images/agents/30-days-of-agents/bootcamp-week-4.png) + +Welcome to Week 4! You've mastered agent fundamentals, built custom agents, and +specialized in domain-specific applications. Now you'll dive deep into **context +engineering** - the critical discipline of designing systems that provide agents +with the right information, tools, and context to accomplish complex tasks +effectively. + +Context engineering is what separates basic chatbots from truly intelligent +agents that can reason about complex problems and take meaningful actions. + +## What's context engineering? + +**Context engineering** is the process of building dynamic systems to provide +the right information and tools in the right format such that language models +can plausibly accomplish complex tasks. Context engineering is the bridge +between raw data and actionable intelligence. + +Context engineering encompasses: + +- **Prompt Engineering**: Crafting instructions that guide agent behavior and + reasoning +- **Retrieval & RAG**: Connecting agents to relevant, real-time information + sources +- **Tool Use**: Enabling agents to interact with external systems and APIs +- **Memory & State**: Managing conversation history and maintaining context + across interactions +- **Structured Outputs**: Ensuring agents produce reliable, formatted responses +- **Information Architecture**: Organizing knowledge for optimal agent access + and reasoning + +## Why context engineering matters + +The difference between a helpful agent and a transformative one often comes down +to context engineering: + +**Without proper context engineering:** + +- Agents hallucinate or provide outdated information +- Responses are generic and lack domain-specific insight +- Tool usage is inconsistent and unreliable +- Complex tasks fail due to information gaps + +**With sophisticated context engineering:** + +- Agents access current, relevant information dynamically +- Responses are grounded in real data and domain expertise +- Tool usage is strategic and purposeful +- Complex workflows execute reliably with proper information flow + +## Week 4 learning path + +This week builds your expertise in the core components of context engineering: + +### Days 16-17: Prompt and message engineering + +Master the fundamentals of communication with language models through structured +prompts and optimized user messages. + +### Days 18-20: Retrieval systems + +Implement sophisticated information retrieval systems using PostgreSQL, MongoDB, +and Neo4j to provide agents with dynamic access to relevant data. + +### Days 21-22: Advanced graph knowledge systems + +Explore cutting-edge knowledge graph approaches using Dgraph for complex +reasoning and relationship modeling. + + + + Master prompt structure, iteration techniques, tool use optimization, and structured output generation for reliable agent behavior. + + + + Learn best practices for crafting user messages that elicit optimal agent + responses and enable complex task completion. + + + + Build RAG systems with Supabase and PostgreSQL, implementing semantic search + over structured product catalogs. + + + + Implement document-based retrieval systems using MongoDB Atlas for + unstructured data like product reviews and feedback. + + + + Explore graph-based retrieval augmented generation using Neo4j for complex + relationship reasoning and knowledge discovery. + + + + Learn advanced graph data modeling concepts with Dgraph, building + sophisticated knowledge graphs from real-world data. + + + + Master DQL (Dgraph Query Language) for complex graph queries and integrate Dgraph with your agents using multiple client libraries. + + + +## The context engineering mindset + +Effective context engineering requires thinking systematically about information +flow: + +- **Information architecture** How should knowledge be structured for optimal + agent access? + +- **Retrieval strategy** What information does the agent need, when, and in what + format? + +- **Tool orchestration** How should agents coordinate multiple information + sources and tools? + +- **Quality assurance** How do we ensure information accuracy and relevance? + +- **Performance optimization** How do we balance information completeness with + response speed? + +## Real-world applications + +By the end of Week 4, you'll be able to build agents that: + +- **Customer Support Agents** that dynamically retrieve product information, + order history, and knowledge base articles +- **Research Assistants** that synthesize information from multiple databases + and external sources +- **Business Intelligence Agents** that query complex data relationships and + provide actionable insights +- **Content Creation Agents** that access brand guidelines, style guides, and + historical content for consistent output + +## Prerequisites + +- Completion of Weeks 1-3 (agent fundamentals and domain specialization) +- Access to Hypermode Pro for advanced integrations +- Willingness to work with databases and data modeling concepts + + + Begin with Day 16: agent system prompts - master the foundation of agent + communication and behavior guidance. + + +--- + +_Transform your agents from conversational tools to intelligent systems that +reason about complex problems with sophisticated context engineering._ diff --git a/agents/30-days-of-agents/day-16.mdx b/agents/30-days-of-agents/day-16.mdx new file mode 100644 index 00000000..94f0edf7 --- /dev/null +++ b/agents/30-days-of-agents/day-16.mdx @@ -0,0 +1,365 @@ +--- +title: "Day 16: Agent System Prompts - The Foundation of Agent Behavior" +sidebarTitle: "Day 16: Agent System Prompts" +description: + "Master the art of system prompt engineering to guide agent behavior, optimize + tool usage, and ensure structured outputs for reliable agent performance." +--- + + + **Goal**: master system prompt engineering for reliable agent behavior + +**Theme**: context engineering week - prompt engineering fundamentals + +**Time investment**: ~25 minutes + + + +Welcome to Day 16 and Week 4! You've built sophisticated agents across multiple +domains. Now you'll master **context engineering** - starting with the +foundation: system prompts. Today you'll learn to craft prompts that reliably +guide agent behavior, optimize tool usage, and produce structured outputs. + +System prompts are the invisible foundation that determines whether your agent +is helpful or frustrating, reliable, or unpredictable. + +## What you'll accomplish today + +- Understand the anatomy of effective system prompts +- Learn iterative prompt refinement techniques +- Optimize prompts for better tool usage patterns +- Master structured output generation +- Apply prompt engineering best practices to your existing agents + + + This builds on your agent creation experience from Weeks 2-3. You'll be + refining and optimizing the prompts of agents you've already built. + + +## Step 1: Anatomy of effective system prompts + +Before optimizing prompts, understand what makes them work: + +### Core prompt structure + +Effective system prompts follow a clear hierarchy: + +```text +Identity: Who is the agent and what is their role? +Context: What environment do they operate in? +Capabilities: What can they do and how? +Constraints: What should they avoid or be careful about? +Output Format: How should they structure responses? +Examples: What does good performance look like? +``` + +### The psychology of prompts + +Language models respond differently to different prompt styles: + +**Authoritative vs. Collaborative**: "You are an expert analyst" vs. "You help +users analyze data" + +**Specific vs. General**: "Analyze Q3 revenue trends" vs. "Help with business +analysis" + +**Process-oriented vs. Outcome-oriented**: "Follow these steps" vs. "Achieve +this goal" + + + **Prompt engineering mindset** Think of prompts as job descriptions combined + with training manuals. Be specific about both what to do and how to do it. + + +## Step 2: Analyze your current agent prompts + +Let's start by examining the prompts of agents you've built in previous weeks: + +**Access your agent's system prompt:** + +1. **Select one of your custom agents** from the sidebar +2. **Click the agent's name** to open the About section +3. **Review the current instructions** that define the agent's behavior + +**Evaluate your current prompt:** + +```text +I want to analyze my current system prompt for effectiveness. Here's my current prompt: + +[Paste your agent's current system prompt] + +Can you evaluate this prompt across these dimensions: +- Clarity of role and identity +- Specificity of instructions +- Tool usage guidance +- Output format specifications +- Potential ambiguities or gaps +``` + +Watch how your agent analyzes its own instructions and identifies improvement +opportunities. + +### Common prompt issues + +Look for these patterns in your current prompts: + +- **Vague role definitions**: "You are a helpful assistant" vs. "You are a + revenue operations analyst" +- **Missing tool guidance**: No instructions on when or how to use specific + tools +- **Unclear output expectations**: No formatting or structure requirements +- **Conflicting instructions**: Contradictory guidance that confuses the model +- **Missing edge case handling**: No guidance for unusual or complex scenarios + +## Step 3: Iterative prompt refinement process + +Prompt engineering is iterative. Here's a systematic approach: + +### The refinement cycle + +1. **Identify specific issues** with current behavior +2. **Hypothesize prompt changes** that might address the issues +3. **Test changes** with specific examples +4. **Measure improvement** objectively +5. **Iterate** until desired behavior is achieved + +### Testing prompt changes + +**Create a test scenario:** + +```text +I want to test a prompt refinement. Here's a specific scenario where my agent isn't performing optimally: + +[Describe the scenario and current behavior] + +Current prompt section that might be the issue: +[Paste relevant prompt section] + +Proposed improvement: +[Your suggested change] + +Can you help me test this change and predict likely improvements? +``` + +### Measuring improvement + +Track these metrics as you refine: + +- **Task completion rate**: Does the agent accomplish what's requested? +- **Tool usage efficiency**: Does it choose the right tools at the right time? +- **Output consistency**: Are responses formatted correctly and consistently? +- **Error reduction**: Fewer hallucinations, mistakes, or inappropriate + responses? + + + **Pro tip** Keep a "prompt lab notebook" documenting what changes led to what + improvements. This builds your intuition for effective prompt engineering. + + +## Step 4: Optimizing prompts for tool usage + +One of the most critical aspects of agent prompts is guiding effective tool +usage: + +### Tool usage patterns + +**Tool selection guidance:** + +```text +When deciding which tools to use: +1. For data analysis tasks, prioritize Google Sheets for structured data +2. For research tasks, use web search first, then supplement with specific databases +3. For communication tasks, choose Slack for internal team updates, Gmail for external +4. Always explain your tool selection reasoning to the user +``` + +**Tool sequencing instructions:** + +```text +For complex workflows: +1. Gather all necessary information before taking actions +2. Confirm destructive actions (deleting, sending emails) with the user +3. Use the most reliable tool first, then fall back to alternatives +4. Report progress after each major tool usage +``` + +### Example tool optimization + +**Before optimization:** + +```text +You can use various tools to help users with their tasks. +``` + +**After optimization:** + +```text +Tool Usage Guidelines: +- GitHub: Use for code review, repository management, and development workflows +- Google Sheets: Use for data analysis, reporting, and collaborative documentation +- Slack: Use for team communications and status updates (always prefix with "Agent:") +- Gmail: Use for external communications and formal correspondence + +Always explain why you're choosing a specific tool and ask for confirmation before taking actions that affect external systems. +``` + +## Step 5: Structured output generation + +Reliable agents produce consistent, properly formatted outputs: + +### Output format specifications + +**Structured response templates:** + +```text +For analysis tasks, use this format: +## Executive Summary +[2-3 sentence overview] + +## Key Findings +- [Finding 1 with supporting data] +- [Finding 2 with supporting data] +- [Finding 3 with supporting data] + +## Recommendations +1. [Priority 1 action with timeline] +2. [Priority 2 action with timeline] +3. [Priority 3 action with timeline] + +## Next Steps +[Specific actions for follow-up] +``` + +**Conditional formatting:** + +```text +Response format depends on request type: +- For quick questions: Single paragraph answer +- For analysis requests: Use the structured template above +- For task completion: Bullet point summary of actions taken +- For errors: Clear explanation of what went wrong and suggested alternatives +``` + +### JSON output for integration + +When agents need to produce data for other systems: + +```text +For structured data requests, respond with valid JSON in this format: +{ + "status": "success|error", + "data": { + // Relevant data fields + }, + "summary": "Human-readable explanation", + "next_actions": ["suggested", "follow-up", "actions"] +} +``` + +## Step 6: Advanced prompt engineering techniques + +### Context management + +**Dynamic context inclusion:** + +```text +Adapt your responses based on conversation history: +- For first interactions: Provide more background and explanation +- For ongoing conversations: Reference previous context and build on established understanding +- For complex topics: Break information into digestible chunks +``` + +**Memory and state management:** + +```text +Maintain awareness of: +- User preferences established in previous conversations +- Ongoing projects and their current status +- Recent actions taken and their outcomes +- Key relationships and context from user's work environment +``` + +### Error handling and edge cases + +**Graceful degradation:** + +```text +When encountering errors or limitations: +1. Clearly explain what went wrong +2. Suggest alternative approaches +3. Ask clarifying questions if the request was ambiguous +4. Offer to break complex tasks into smaller steps +``` + +## What you've accomplished + +In 25 minutes, you've mastered system prompt engineering: + +**Prompt analysis skills**: learned to evaluate and identify weaknesses in +existing prompts + +**Iterative refinement process**: developed a systematic approach to prompt +improvement + +**Tool usage optimization**: crafted prompts that guide effective tool selection +and usage + +**Structured output mastery**: created templates for consistent, reliable agent +responses + +**Advanced techniques**: implemented context management and error handling in +prompts + +## The power of engineered prompts + +Well-engineered prompts transform agent behavior: + +**Before optimization** Agents that are unpredictable, verbose, and make poor +tool choices + +**After optimization** Agents that are reliable, focused, and strategically use +tools to accomplish tasks + +This foundation enables everything else in context engineering - retrieval, +memory, and complex reasoning. + + + Master the art of user message engineering - crafting requests that elicit + optimal agent responses and enable complex task completion. + + +## Pro tip for today + +After optimizing your prompts, test them with edge cases: + +```text +Test my refined agent prompt with these challenging scenarios: +1. Ambiguous requests that could be interpreted multiple ways +2. Requests for information the agent doesn't have access to +3. Tasks that require multiple tools in sequence +4. Error conditions where tools fail or return unexpected results + +How does the agent handle these situations with the new prompt? +``` + +This reveals remaining prompt gaps and helps you build truly robust agent +behavior. + +--- + +**Time to complete**: ~25 minutes + +**Skills learned**: prompt structure analysis, iterative refinement, tool usage +optimization, structured output design, advanced prompt engineering techniques + +**Next**: day 17 - User message engineering and communication optimization + + + **Remember**: great prompts are invisible to users but obvious in their + effects. The best agents feel naturally intelligent because their prompts + guide behavior so effectively. + diff --git a/agents/30-days-of-agents/day-17.mdx b/agents/30-days-of-agents/day-17.mdx new file mode 100644 index 00000000..aed898b4 --- /dev/null +++ b/agents/30-days-of-agents/day-17.mdx @@ -0,0 +1,368 @@ +--- +title: "Day 17: Agent User Messages - The Art of Agent Communication" +sidebarTitle: "Day 17: Agent User Messages" +description: + "Learn best practices for crafting user messages that elicit optimal agent + responses, enable complex task completion, and establish effective human-agent + collaboration patterns." +--- + + + **Goal**: master user message engineering for optimal agent collaboration + +**Theme**: context engineering week - communication optimization + +**Time investment**: ~20 minutes + + + +Welcome to Day 17! Yesterday you mastered system prompts that guide agent +behavior. Today you'll learn the other half of the conversation: **user message +engineering**. You'll discover how to craft requests that elicit optimal agent +responses and enable complex task completion. + +Great user messages are the difference between agents that frustrate you and +agents that feel like the perfect colleague. + +## What you'll accomplish today + +- Understand the anatomy of effective user messages +- Learn communication patterns that maximize agent capability +- Master techniques for complex task delegation +- Develop strategies for iterative problem-solving with agents +- Build repeatable communication frameworks for consistent results + + + This builds on Day 16's prompt engineering foundation. You'll be practicing + with the agents you've optimized to see how message quality affects outcomes. + + +## Step 1: The anatomy of effective user messages + +Just as system prompts have structure, effective user messages follow +predictable patterns: + +### Core message components + +- **Context**: What background does the agent need? +- **Goal**: What are you trying to accomplish? +- **Constraints**: What limitations or requirements exist? +- **Format**: How should the output be structured? +- **Success criteria**: How will you know if it worked? + +### Message clarity hierarchy + +**Level 1 - Basic requests** Simple, single-step tasks + +```text +"Create a calendar event for tomorrow at 2 PM" +``` + +**Level 2 - Contextual requests** Tasks with background information + +```text +"Create a calendar event for tomorrow at 2 PM with the client we discussed yesterday - include the project proposal as agenda item" +``` + +**Level 3 - Strategic requests** Complex, multi-step workflows + +```text +"Prepare for tomorrow's client meeting at 2 PM: research their recent announcements, +update the project proposal based on our last conversation, and create a follow-up task list based on likely outcomes" +``` + + + **Communication principle** Agents perform better when they understand not + just what to do, but why they're doing it and how it fits into larger goals. + + +## Step 2: Communication patterns that maximize agent capability + +Different types of requests require different communication approaches: + +### The CLEAR framework + +- **Context**: Provide relevant background +- **Limits**: Define scope and constraints +- **Expectations**: Specify desired outcomes +- **Actions**: Suggest approach if helpful +- **Review**: Plan for feedback and iteration + +### Request type patterns + +**Information gathering requests:** + +```text +Good: "Research our top 3 competitors' pricing strategies, focusing on their enterprise tiers. + I need this for our pricing review meeting next week - include key differentiators and market positioning." + +Poor: "Look up competitor pricing" +``` + +**Action-taking requests:** + +```text +Good: "Create a Slack message for the #engineering channel announcing our API v2.0 release. +Include the key improvements (performance, new endpoints, breaking changes) and link to the migration guide. Schedule it for 9 AM tomorrow." + +Poor: "Post about the API release" +``` + +**Analysis requests:** + +```text +Good: "Analyze last quarter's sales pipeline data from HubSpot. +I want to understand our conversion rates by source, identify which stages have the biggest drop-offs, and recommend 3 specific improvements for next quarter." + +Poor: "Look at sales data" +``` + +### Progressive elaboration technique + +Start simple, then add complexity: + +```text +1. Initial request: "Help me prepare for tomorrow's board meeting" + +2. Add context: "Help me prepare for tomorrow's board meeting where we're discussing Q4 performance and 2025 strategy" + +3. Add specifics: "Help me prepare for tomorrow's board meeting on Q4 performance and 2025 strategy. +I need: current metrics summary, comparison to goals, key wins/challenges, and our top 3 strategic priorities for next year" + +4. Add constraints: "Help me prepare for tomorrow's board meeting on Q4 performance and 2025 strategy. +I need: current metrics summary, comparison to goals, key wins/challenges, and our top 3 strategic priorities for next year. +Keep everything concise - the deck should be 10 slides max, and focus on actionable insights rather than raw data." +``` + +## Step 3: Complex task delegation strategies + +Breaking down complex work into manageable agent tasks: + +### The decomposition approach + +**Instead of**: "Plan our product launch" + +**Try this sequence**: + +```text +1. "Research successful product launches in our space over the last year - what tactics, timelines, and channels did they use?" + +2. "Based on that research and our product features, create a high-level launch timeline with key milestones" + +3. "For each milestone, identify what assets we'll need, who's responsible, and what success looks like" + +4. "Create a detailed project plan for the first 4 weeks with specific tasks and deadlines" +``` + +### Dependency management + +Help agents understand task relationships: + +```text +"I need to create a customer onboarding email sequence. +First, analyze our current customer feedback to identify the top 3 onboarding pain points. +Then, draft email templates that address each pain point. +Finally, suggest an automation workflow in HubSpot to deliver these emails based on user behavior." +``` + +### Quality checkpoints + +Build verification into complex tasks: + +```text +"Create a competitive analysis report. +After you gather the initial research, summarize your findings and ask if I want + you to dive deeper into any specific areas before proceeding to the full report." +``` + + + **Complex task strategy** Think of agents as highly capable interns. Give them + meaningful work, clear context, and check in at key decision points. + + +## Step 4: Iterative problem-solving techniques + +Agents excel at iterative refinement when guided properly: + +### The spiral approach + +**Start broad, then narrow**: + +```text +1. "What are the main approaches to improving our customer retention?" + +2. "Focus on the top 3 approaches - give me specific tactics for each" + +3. "For the email engagement approach, create a detailed implementation plan" + +4. "Draft the first email in that sequence targeting customers who haven't used our key features" +``` + +### Feedback integration + +Help agents learn from your responses: + +```text +"That analysis is helpful, but I need more focus on the financial impact. +Can you redo the recommendations section with specific revenue/cost projections for each suggestion?" +``` + +### Course correction + +Guide agents back on track when they drift: + +```text +"I appreciate the comprehensive research, but let's refocus on the original +question about pricing strategy. Can you distill those findings into 3 actionable pricing adjustments we could implement this quarter?" +``` + +## Step 5: Building repeatable communication frameworks + +Develop templates for common interaction patterns: + +### Framework templates + +**Research requests**: + +```text +Research [topic] for [purpose/context]. +Focus on [specific aspects]. +I need this by [deadline] for [intended use]. +Format as [output type] and include [specific elements]. +``` + +**Analysis requests**: + +```text +Analyze [data source] to answer [specific question]. +Consider [key factors] and provide [output format]. +Include recommendations prioritized by [criteria]. +``` + +**Creation requests**: + +```text +Create [deliverable] for [audience/purpose]. +Use [style/tone] and include [required elements]. +Format should be [specifications] and optimized for [intended use]. +``` + +### Situation-specific patterns + +**Weekly reviews**: + +```text +"Run my weekly [department] review: check progress on active projects, identify any blockers, summarize key metrics vs. goals, +and flag anything needing my attention this week." +``` + +**Meeting preparation**: + +```text +"Prepare me for [meeting type] with [attendees] about [topic]. + Include: recent context about [relevant area], talking points for [specific agenda items], and potential questions I might face." +``` + +**Project updates**: + +```text +"Create a project status update for [project] covering progress since [last update], +current status vs. timeline, upcoming milestones, and any risks or blockers." +``` + +## Step 6: Advanced communication techniques + +### Context threading + +Reference previous conversations effectively: + +```text +"Building on the competitive analysis we discussed yesterday, +now create a positioning strategy that addresses the gaps we identified in our enterprise messaging." +``` + +### Perspective taking + +Help agents understand different viewpoints: + +```text +"Draft this announcement from the perspective of our customer success team - they'll need to field questions about the changes, +so include likely concerns and talking points for addressing them." +``` + +### Constraint optimization + +Work within realistic limitations: + +```text +"Given that we only have 2 weeks and a $5K budget, +what's the highest-impact marketing campaign we could run for this product launch? +Focus on tactics that leverage our existing assets and team expertise." +``` + +## What you've accomplished + +In 20 minutes, you've mastered user message engineering: + +**Communication frameworks**: learned structured approaches to agent requests + +**Task decomposition**: developed strategies for breaking complex work into +manageable pieces + +**Iterative refinement**: mastered techniques for progressive problem-solving +with agents + +**Quality optimization**: built methods for getting better outputs through +better inputs + +**Repeatable patterns**: created templates for common interaction types + +## The power of engineered communication + +Well-crafted user messages unlock agent potential: + +**Before optimization** Vague requests leading to generic responses and multiple +rounds of clarification + +**After optimization** Precise requests that elicit targeted, actionable +responses on the first try + +Combined with yesterday's prompt engineering, you now control both sides of the +human-agent conversation. + + + Begin building RAG (Retrieval Augmented Generation) systems with PostgreSQL + and Supabase for dynamic information access. + + +## Pro tip for today + +Practice the spiral approach with one of your agents: + +```text +"Let's practice iterative problem-solving. +Start by giving me a high-level overview of [complex topic relevant to your work]. +Then we'll drill down into specifics based on what I find most interesting or useful." +``` + +This builds your intuition for guiding agents through complex reasoning +processes. + +--- + +**Time to complete**: ~20 minutes + +**Skills learned**: message structure optimization, task decomposition +strategies, iterative problem-solving, communication frameworks, advanced +delegation techniques + +**Next**: day 18 - Retrieval systems with PostgreSQL and Supabase + + + **Remember**: agents are mirrors of the communication they receive. Invest in + crafting better requests, and you'll get exponentially better results. + diff --git a/agents/30-days-of-agents/day-18.mdx b/agents/30-days-of-agents/day-18.mdx new file mode 100644 index 00000000..62f09c46 --- /dev/null +++ b/agents/30-days-of-agents/day-18.mdx @@ -0,0 +1,341 @@ +--- +title: "Day 18: Retrieval with PostgreSQL - Building Retrieval Systems" +sidebarTitle: "Day 18: PostgreSQL Retrieval" +description: + "Build sophisticated retrieval systems using PostgreSQL and Supabase, + implementing semantic search over structured product catalogs for intelligent + information retrieval." +--- + + + **Goal**: build a production-ready RAG system using PostgreSQL and Supabase + +**Theme**: context engineering week - information retrieval systems + +**Time investment**: ~30 minutes + + + +Welcome to Day 18! You've mastered prompt and message engineering. Now you'll +build **RAG (Retrieval Augmented Generation) systems** - the foundation of +intelligent information access. Today you'll use PostgreSQL and Supabase to +create semantic search over structured data. + +RAG systems enable agents to access current, relevant information dynamically +rather than relying solely on training data. + +## What you'll accomplish today + +- Set up a Supabase PostgreSQL database +- Load and index an Amazon product catalog as example data +- Connect your agent to Supabase for intelligent retrieval +- Implement semantic search queries that enhance agent responses +- Build retrieval patterns that scale to real-world data volumes + + + This requires setting up external services (Supabase). You'll need to create + accounts and configure database connections. The concepts apply to any + PostgreSQL-based retrieval system. + + +## Step 1: Understanding retrieval systems + +Before building, understand what makes retrieval powerful: + +### Retrieval architecture components + +- **Knowledge Base**: Structured or unstructured data that agents can search +- **Embedding Model**: Converts text to vector representations for similarity + search +- **Vector Database**: Stores and searches embeddings efficiently +- **Retrieval System**: Finds relevant information based on user queries +- **Generation**: Language model uses retrieved context to provide informed + responses + +### When to use retrieval vs. fine-tuning + +**Retrieval is ideal for**: + +- Dynamic information that changes frequently +- Large knowledge bases that exceed context windows +- Information that needs to be traceable and verifiable +- Scenarios where you need to add new information without retraining + +**Fine-tuning is better for**: + +- Changing behavior patterns or writing style +- Domain-specific reasoning capabilities +- When information is stable and doesn't change often + + + **Retrieval thinking** Think of retrieval as giving your agent access to a + dynamic, searchable library rather than memorizing everything up front. + + +## Set up Supabase + +Supabase provides PostgreSQL with built-in vector search capabilities: + +### Create your Supabase project + +1. **Visit [Supabase.com](https://supabase.com)** and create a free account +2. **Create a new project** and note your project URL and API keys +3. **Set up authentication** and database permissions + +## Load Amazon product catalog data + +Let's create a realistic product dataset for testing: + +### Sample product data + +Create sample product data that represents a typical e-commerce catalog. +Navigate to the SQL editor in Supabase and run the following SQL: + +{/* */} + +```sql +-- Insert sample Amazon-style product data +INSERT INTO products (title, description, category, price, rating, metadata) VALUES +('Apple iPhone 15 Pro', 'Latest iPhone with titanium design, A17 Pro chip, and advanced camera system', 'Electronics', 999.00, 4.5, '{"brand": "Apple", "features": ["A17 Pro chip", "Titanium", "Advanced camera"]}'), +('Samsung Galaxy S24 Ultra', 'Premium Android smartphone with S Pen, 200MP camera, and AI features', 'Electronics', 1199.00, 4.3, '{"brand": "Samsung", "features": ["S Pen", "200MP camera", "AI features"]}'), +('Sony WH-1000XM5 Headphones', 'Industry-leading noise canceling wireless headphones with 30-hour battery life', 'Audio', 399.99, 4.7, '{"brand": "Sony", "features": ["Noise canceling", "30-hour battery", "Wireless"]}'), +('Dyson V15 Detect Vacuum', 'Cordless vacuum with laser dust detection and intelligent suction adjustment', 'Home & Garden', 749.99, 4.4, '{"brand": "Dyson", "features": ["Laser detection", "Cordless", "Intelligent suction"]}'), +('Nike Air Max 270', 'Comfortable running shoes with Max Air cushioning and breathable mesh upper', 'Sports & Outdoors', 149.99, 4.2, '{"brand": "Nike", "features": ["Max Air cushioning", "Breathable mesh", "Running"]}'), +('Instant Pot Duo 7-in-1', 'Multi-functional electric pressure cooker that replaces 7 kitchen appliances', 'Kitchen', 79.99, 4.6, '{"brand": "Instant Pot", "features": ["7-in-1", "Pressure cooker", "Electric"]}'), +('MacBook Pro 16-inch M3', 'Professional laptop with M3 chip, stunning Liquid Retina XDR display', 'Computers', 2499.00, 4.8, '{"brand": "Apple", "features": ["M3 chip", "Liquid Retina XDR", "Professional"]}'), +('Amazon Echo Dot 5th Gen', 'Smart speaker with Alexa, improved audio, and smart home control', 'Smart Home', 49.99, 4.1, '{"brand": "Amazon", "features": ["Alexa", "Smart home control", "Improved audio"]}'), +('Fitbit Charge 6', 'Advanced fitness tracker with GPS, heart rate monitoring, and 6-day battery', 'Health & Fitness', 199.99, 4.3, '{"brand": "Fitbit", "features": ["GPS", "Heart rate monitoring", "6-day battery"]}'), +('Weber Genesis E-325s', 'Premium gas grill with three burners, porcelain-enameled cast iron grates', 'Outdoor', 899.00, 4.5, '{"brand": "Weber", "features": ["Three burners", "Cast iron grates", "Premium gas grill"]}'), +('OLED TV 55-inch 4K', 'Ultra-slim OLED television with perfect blacks and vibrant colors', 'Electronics', 1299.99, 4.6, '{"brand": "LG", "features": ["OLED", "4K", "Ultra-slim"]}'), +('KitchenAid Stand Mixer', 'Professional-grade stand mixer with 10 speeds and tilt-head design', 'Kitchen', 329.99, 4.7, '{"brand": "KitchenAid", "features": ["10 speeds", "Tilt-head design", "Professional-grade"]}'), +('Gaming Laptop RTX 4080', 'High-performance gaming laptop with RTX 4080 graphics and 16GB RAM', 'Computers', 1899.99, 4.4, '{"brand": "ASUS", "features": ["RTX 4080", "16GB RAM", "High-performance"]}'), +('Wireless Charging Stand', 'Fast wireless charging stand compatible with iPhone and Android devices', 'Electronics', 39.99, 4.2, '{"brand": "Anker", "features": ["Fast charging", "Wireless", "Universal compatibility"]}'), +('Espresso Machine Deluxe', 'Semi-automatic espresso machine with milk frother and programmable settings', 'Kitchen', 599.99, 4.5, '{"brand": "Breville", "features": ["Semi-automatic", "Milk frother", "Programmable"]}'); +``` + +{/* */} + +## Connect your agent to Supabase + +Now integrate your retrieval system with your Hypermode agent: + +### Add Supabase connection + +1. **Navigate to your agent's connections** in the About section +2. **Add Supabase connection** and configure with your project credentials +3. **Test the connection** by querying the products table + +Refer to the [Hypermode Supabase connection docs](/agents/connections/supabase) +for more information. + +### Create a retrieval-enabled agent + +If you don't have a suitable agent, create one with Concierge: + +```text +I want to create a product recommendation agent that helps users find products based on their needs. + +The agent should: +- Search to find relevant products from our catalog +- Understand user preferences and requirements +- Provide detailed product comparisons and recommendations +- Explain why specific products match user needs +- Handle follow-up questions about features, pricing, and alternatives + +The agent should act like a knowledgeable sales associate who understands both product details and customer needs. +``` + +### Configure retrieval workflows + +Add these patterns to your agent's instructions: + +```text +Product Search Guidelines: +1. When users ask about products, use search on the products database +2. Search using natural language descriptions of user needs +3. Include relevant product details: title, description, price, rating, and key features +4. Explain why recommended products match the user's requirements +5. Offer comparisons between similar products when helpful +6. Always provide specific product information rather than generic advice +``` + +## Implement retrieval queries + +Test your retrieval system with real queries: + +### Basic product search + +```text +I'm looking for a smartphone with good camera quality and long battery life under $800. What would you recommend? +``` + +Your agent should: + +1. **Query the products table** +2. **Return relevant products** with explanations +3. **Format results** with specific details and reasoning + +### Complex requirement matching + +```text +I need a gift for someone who loves cooking and wants to save time in the kitchen. Budget is around $100. What products would be perfect? +``` + +Watch how semantic search finds relevant products even when the query doesn't +contain exact product keywords. + +### Comparison queries + +```text +Compare the top 3 headphones in your catalog and explain which is best for different use cases. +``` + +This tests the agent's ability to retrieve multiple products and synthesize +comparative information. + + + **Retrieval quality** Good retrieval systems return not just similar products, + but contextually relevant ones that actually answer the user's underlying + need. + + +### Contextual retrieval + +Help your agent understand search context: + +```text +Retrieval Context Guidelines: +- For gift recommendations: Consider price range, recipient interests, and occasion +- For replacements: Find similar products with improvements or better value +- For comparisons: Retrieve products in the same category with different strengths +- For budget searches: Prioritize value and essential features within price range +- For premium searches: Focus on quality, features, and brand reputation +``` + +### Advanced query examples + +Test sophisticated retrieval patterns: + +```text +"I want to upgrade my home office setup for better productivity and comfort. I have a $1000 budget and work from home 8 hours a day." +``` + +```text +"Find me eco-friendly alternatives to common household items that also save money in the long run." +``` + +```text +"I'm a beginner cook who wants to make healthier meals but has limited time. What kitchen tools would be most impactful?" +``` + +## Performance optimization and monitoring + +Ensure your retrieval system performs well at scale: + +### Indexing optimization + +```sql +-- Create additional indexes for common query patterns +CREATE INDEX idx_products_category ON products(category); +CREATE INDEX idx_products_price ON products(price); +CREATE INDEX idx_products_rating ON products(rating); +CREATE INDEX idx_products_brand ON products USING GIN ((metadata->>'brand')); + +-- Full-text search index +CREATE INDEX idx_products_fulltext ON products USING GIN (to_tsvector('english', title || ' ' || description)); +``` + +### Query performance monitoring + +```sql +-- Enable query statistics +SELECT pg_stat_statements_reset(); + +-- Monitor slow queries +SELECT query, calls, total_time, mean_time, rows +FROM pg_stat_statements +WHERE query LIKE '%products%' +ORDER BY mean_time DESC +LIMIT 10; +``` + +### Retrieval quality metrics + +Track these metrics to ensure good RAG performance: + +- **Retrieval precision**: How many retrieved items are relevant? +- **Retrieval recall**: How many relevant items are retrieved? +- **Response time**: How fast are queries executing? +- **User satisfaction**: Are users finding what they need? + +## What you've accomplished + +In 30 minutes, you've built a production-ready RAG system: + +**Database foundation**: set up PostgreSQL with vector search capabilities + +**Data pipeline**: loaded and indexed structured product catalog with embeddings + +**Agent integration**: connected your agent to Supabase for dynamic information +retrieval + +**Semantic search**: implemented vector similarity search for intelligent +product discovery + +**Advanced patterns**: explored hybrid search, filtering, and contextual +retrieval + +**Performance optimization**: learned indexing and monitoring strategies for +production use + +## The power of retrieval systems + +Retrieval transforms static agents into dynamic information systems: + +**Before retrieval** Agents limited to training data and general knowledge + +**After retrieval** Agents with access to current, specific, searchable +knowledge bases + +This foundation enables agents to provide accurate, up-to-date information from +your own data sources. + + + Implement document-based retrieval systems using MongoDB Atlas for + unstructured data like product reviews and feedback. + + +## Pro tip for today + +Test retrieval quality with diverse queries: + +```text +Test my retrieval system with these different query types: +1. Specific product searches: "wireless noise-canceling headphones" +2. Use case searches: "products for home office productivity" +3. Comparative searches: "best value smartphones under $500" +4. Problem-solving searches: "solutions for small kitchen storage" + +How well does semantic search understand intent vs. exact keywords? +``` + +This reveals the strengths and limitations of your retrieval system. + +--- + +**Time to complete**: ~30 minutes + +**Skills learned** RAG system architecture, PostgreSQL vector search, embedding +generation, semantic retrieval, hybrid search patterns, performance optimization + +**Next**: day 19 - Document retrieval with MongoDB for unstructured data + + + **Remember** Retrieval quality depends on both the relevance of retrieved + information and how well your agent uses that information to generate + responses. Both sides matter equally. + diff --git a/agents/30-days-of-agents/day-19.mdx b/agents/30-days-of-agents/day-19.mdx new file mode 100644 index 00000000..b302989b --- /dev/null +++ b/agents/30-days-of-agents/day-19.mdx @@ -0,0 +1,422 @@ +--- +title: "Day 19: Retrieval with MongoDB - Document-Based RAG Systems" +sidebarTitle: "Day 19: MongoDB Retrieval" +description: + "Implement sophisticated document-based retrieval systems using MongoDB Atlas + for unstructured data like product reviews, feedback, and content analysis." +--- + + + **Goal**: build document-based retrieval with MongoDB for unstructured data retrieval + +**Theme**: context engineering week - NoSQL and document retrieval + +**Time investment**: ~25 minutes + + + +Welcome to Day 19! Yesterday you built structured RAG systems with PostgreSQL. +Today you'll work with **unstructured document retrieval** using MongoDB Atlas. +You'll learn to search through product reviews, feedback, and content where the +structure varies and context is embedded in natural language. + +Document-based retrieval excels when dealing with varied, unstructured content +that doesn't fit neatly into database tables. + +## What you'll accomplish today + +- Set up MongoDB Atlas with vector search capabilities for document retrieval +- Load Amazon product reviews as example unstructured data +- Connect your agent to MongoDB for intelligent document search +- Build retrieval patterns for sentiment analysis and contextual understanding + + + This requires setting up MongoDB Atlas (free tier available). You'll be + working with unstructured documents that require different indexing and search + strategies than structured data. + + +## Step 1: Understanding document-based retrieval + +Document databases handle unstructured data differently than relational +databases: + +### Document and relational data + +**Relational data (Day 18)**: + +- Fixed schema with defined columns +- Structured relationships between tables +- Efficient for transactional operations +- Great for precise, attribute-based queries + +**Document data (Today)**: + +- Flexible schema with nested objects and arrays +- Self-contained documents with varying structures +- Efficient for content storage and retrieval +- Great for text analysis and semantic search + +### When to use document-based retrieval + +**Ideal for**: + +- Product reviews and customer feedback +- Content analysis (blogs, articles, documentation) +- Social media posts and comments +- Support tickets and conversation logs +- Research papers and knowledge articles + +**Not ideal for**: + +- Highly structured transactional data +- Complex multi-table relationships +- Frequent schema changes requiring migrations + + + **Document thinking** Think of document retrieval as searching through a + library of books rather than looking up entries in a catalog. Context and + content matter more than exact structure. + + +## Step 2: Set up MongoDB Atlas with vector search + +MongoDB Atlas provides managed MongoDB with built-in vector search: + +### Create your MongoDB Atlas cluster + +1. **Visit [mongodb.com/atlas](https://mongodb.com/atlas)** and create a free + account +2. **Create a new cluster** (M0 free tier is sufficient for learning) +3. **Set up database access** with username/password authentication +4. **Configure network access** to allow connections from your IP +5. **Get your connection string** for later use + +### Create the reviews collection + +```javascript +// Connect to your MongoDB instance and create the reviews collection +use product_reviews + +// Create collection with validation schema +db.createCollection("reviews", { + validator: { + $jsonSchema: { + bsonType: "object", + required: ["product_id", "product_title", "review_text", "rating"], + properties: { + product_id: { bsonType: "string" }, + product_title: { bsonType: "string" }, + review_text: { bsonType: "string" }, + rating: { bsonType: "number", minimum: 1, maximum: 5 }, + reviewer_name: { bsonType: "string" }, + review_date: { bsonType: "date" }, + verified_purchase: { bsonType: "bool" }, + helpful_votes: { bsonType: "number" }, + embedding: { bsonType: "array" } + } + } + } +}) +``` + +## Load Amazon product reviews data + +Create a realistic dataset of product reviews with varying structures: + +### Sample review documents + +{/* */} + +```javascript +// Insert sample Amazon-style product reviews +db.reviews.insertMany([ + { + product_id: "iphone15pro", + product_title: "Apple iPhone 15 Pro", + review_text: + "Absolutely love this phone! The camera quality is incredible, especially in low light. The titanium build feels premium and the battery easily lasts all day. The Action Button is a nice touch. Only downside is the price, but you get what you pay for with Apple.", + rating: 5, + reviewer_name: "TechEnthusiast2024", + review_date: new Date("2024-10-15"), + verified_purchase: true, + helpful_votes: 23, + features_mentioned: ["camera", "battery", "titanium", "Action Button"], + sentiment: "positive", + }, + { + product_id: "iphone15pro", + product_title: "Apple iPhone 15 Pro", + review_text: + "Camera is good but not revolutionary. Battery life is decent but nothing special. The phone feels nice but is way overpriced for what you get. Android flagships offer better value. Not impressed with iOS limitations either.", + rating: 3, + reviewer_name: "AndroidUser42", + review_date: new Date("2024-11-02"), + verified_purchase: true, + helpful_votes: 8, + features_mentioned: ["camera", "battery", "price", "iOS"], + sentiment: "neutral", + }, + { + product_id: "galaxy_s24_ultra", + product_title: "Samsung Galaxy S24 Ultra", + review_text: + "The S Pen integration is fantastic for note-taking and creative work. Display is gorgeous and the camera zoom capabilities are unmatched. AI features are actually useful, especially for photo editing. Great phone for productivity.", + rating: 5, + reviewer_name: "ProductivityPro", + review_date: new Date("2024-09-28"), + verified_purchase: true, + helpful_votes: 15, + features_mentioned: ["S Pen", "display", "camera zoom", "AI features"], + sentiment: "positive", + }, + { + product_id: "sony_wh1000xm5", + product_title: "Sony WH-1000XM5 Headphones", + review_text: + "These headphones are a game changer for my daily commute. Noise cancellation is outstanding - completely blocks out subway noise. Sound quality is crisp and balanced. Comfort is excellent for long wearing sessions. Battery life is as advertised. Highly recommend!", + rating: 5, + reviewer_name: "CommuterLife", + review_date: new Date("2024-10-20"), + verified_purchase: true, + helpful_votes: 31, + features_mentioned: [ + "noise cancellation", + "sound quality", + "comfort", + "battery life", + ], + sentiment: "positive", + }, + { + product_id: "dyson_v15", + product_title: "Dyson V15 Detect Vacuum", + review_text: + "The laser dust detection is amazing - you can see exactly where dust is hiding. Suction power is incredible on all surfaces. However, it's quite heavy for extended use and the battery drains faster than expected on max power. Worth it but has limitations.", + rating: 4, + reviewer_name: "CleaningExpert", + review_date: new Date("2024-11-05"), + verified_purchase: true, + helpful_votes: 12, + features_mentioned: [ + "laser detection", + "suction power", + "weight", + "battery", + ], + sentiment: "mostly_positive", + }, + { + product_id: "nike_air_max_270", + product_title: "Nike Air Max 270", + review_text: + "Comfortable for casual wear but not great for serious running. The cushioning feels good for walking around the city. Style is nice and goes with most outfits. Sizing runs a bit large - order half a size down. Good for the price point.", + rating: 4, + reviewer_name: "CasualRunner", + review_date: new Date("2024-10-08"), + verified_purchase: true, + helpful_votes: 7, + features_mentioned: ["comfort", "cushioning", "style", "sizing"], + sentiment: "positive", + }, + { + product_id: "instant_pot_duo", + product_title: "Instant Pot Duo 7-in-1", + review_text: + "This has revolutionized my meal prep! Makes perfect rice, tender meats, and great yogurt. Learning curve was steep initially but now I use it almost daily. Saves so much time compared to traditional cooking methods. Essential kitchen appliance.", + rating: 5, + reviewer_name: "MealPrepMaster", + review_date: new Date("2024-09-15"), + verified_purchase: true, + helpful_votes: 45, + features_mentioned: ["meal prep", "rice", "yogurt", "time saving"], + sentiment: "positive", + }, + { + product_id: "macbook_pro_m3", + product_title: "MacBook Pro 16-inch M3", + review_text: + "Performance is absolutely incredible for video editing and development work. The M3 chip handles everything I throw at it without breaking a sweat. Display is stunning. Battery life is impressive for such a powerful machine. Premium build quality as expected from Apple.", + rating: 5, + reviewer_name: "VideoEditor_Pro", + review_date: new Date("2024-11-10"), + verified_purchase: true, + helpful_votes: 28, + features_mentioned: [ + "performance", + "M3 chip", + "video editing", + "display", + "battery", + ], + sentiment: "positive", + }, +]) +``` + +{/* */} + +## Connect MongoDB to your agent + +Integrate MongoDB with your Hypermode agent for document retrieval: + +### Add MongoDB connection + +1. **Navigate to your agent's connections** in the About section +2. **Add MongoDB connection** with your Atlas cluster credentials +3. **Test the connection** by querying the reviews collection + +### Create a review analysis agent + +If needed, create a specialized agent with Concierge: + +```text +I want to create a product review analysis agent that helps users understand customer sentiment and experiences. + +The agent should: +- Search through product reviews using semantic similarity +- Analyze customer sentiment and common themes +- Identify specific product strengths and weaknesses mentioned by reviewers +- Compare customer experiences across similar products +- Provide insights about product satisfaction patterns +- Help users understand real customer experiences beyond marketing claims + +The agent should act like a market research analyst who specializes in customer feedback analysis. +``` + +### Configure document retrieval patterns + +Add these instructions to your agent: + +```text +Review Analysis Guidelines: +1. Use semantic search to find relevant reviews based on user interests +2. Look for patterns in customer feedback, not just individual opinions +3. Identify specific product features mentioned by multiple reviewers +4. Consider both positive and negative feedback for balanced insights +5. Explain sentiment trends and common themes across reviews +6. Provide specific quotes from reviews to support analysis +7. Note verified purchases vs. unverified reviews when relevant +``` + +### Implement document search and analysis + +Test your document-based retrieval system: + +### Semantic review search + +```text +What do customers say about camera quality in smartphone reviews? I'm particularly interested in low-light performance. +``` + +Your agent should: + +1. **Search reviews** for camera-related content +2. **Extract specific mentions** of camera features and performance +3. **Analyze sentiment** around camera quality +4. **Provide quotes** from actual reviews +5. **Summarize trends** across multiple customer experiences + +### Sentiment analysis queries + +```text +Analyze customer satisfaction patterns for headphones. What are the most common complaints and praise points? +``` + +This tests the agent's ability to: + +- **Aggregate sentiment** across multiple reviews +- **Identify common themes** in feedback +- **Distinguish between** different types of issues or praise +- **Provide actionable insights** from unstructured feedback + +### Comparative analysis + +```text +Compare customer experiences between iPhone and Samsung phones based on actual user reviews. What are the key differences in satisfaction? +``` + +This requires: + +- **Cross-product analysis** using semantic search +- **Pattern recognition** across different product categories +- **Balanced reporting** of pros and cons +- **Context-aware insights** about user preferences + + + **Document retrieval insight** The power of document-based RAG is in + understanding context and nuance that structured data misses. Focus on + semantic meaning over exact keyword matches. + + +## What you've accomplished + +In 25 minutes, you've mastered document-based RAG systems: + +**MongoDB foundation**: set up Atlas with vector search for document retrieval + +**Unstructured data handling**: loaded and indexed product reviews with flexible +schemas + +**Document search**: implemented search across varying content structures + +**Sentiment analysis**: built patterns for understanding customer feedback and +satisfaction trends + +**Advanced aggregation**: explored complex queries for multi-dimensional +document analysis + +## The power of document-based retrieval + +Document RAG unlocks insights from unstructured content: + +**Before document RAG** Limited to structured product information and marketing +claims + +**After document RAG** Access to real customer experiences, sentiment trends, +and nuanced feedback + +Combined with yesterday's structured RAG, you now have comprehensive information +retrieval capabilities. + + + Explore GraphRAG with Neo4j for complex relationship reasoning and knowledge + discovery through connected data. + + +## Pro tip for today + +Test document retrieval with nuanced queries: + +```text +Test my document RAG system with these complex queries: +1. "What specific issues do customers mention about battery life across different devices?" +2. "How do customer experiences vary between verified and unverified purchasers?" +3. "What patterns emerge when customers compare competing products?" +4. "Which product features generate the most emotional responses in reviews?" + +How well does the system understand context and extract insights from unstructured text? +``` + +This reveals the sophistication of your document-based retrieval system. + +--- + +**Time to complete**: ~25 minutes + +**Skills learned** MongoDB Atlas setup, document-based retrieval, semantic +search across unstructured data, sentiment analysis, advanced aggregation +patterns + +**Next**: day 20 - GraphRAG with Neo4j for relationship-based knowledge +discovery + + + **Remember**: document-based RAG excels at capturing human context, emotion, + and nuanced experiences that structured data often misses. Use it for + understanding "why" not just "what." + diff --git a/agents/30-days-of-agents/day-20.mdx b/agents/30-days-of-agents/day-20.mdx new file mode 100644 index 00000000..60855caa --- /dev/null +++ b/agents/30-days-of-agents/day-20.mdx @@ -0,0 +1,467 @@ +--- +title: "Day 20: GraphRAG with Neo4j - Relationship-Based Knowledge Discovery" +sidebarTitle: "Day 20: GraphRAG with Neo4j" +description: + "Explore GraphRAG using Neo4j for complex relationship reasoning and knowledge + discovery. Build knowledge graphs dynamically and implement sophisticated + graph-based retrieval systems." +--- + + + **Goal**: build GraphRAG systems with Neo4j for relationship-based knowledge discovery + +**Theme**: context engineering week - graph-based retrieval and reasoning + +**Time investment**: ~30 minutes + + + +Welcome to Day 20! You've mastered structured and document-based RAG. Today +you'll explore **GraphRAG** - retrieval augmented generation using graph +databases. You'll learn to build knowledge graphs that capture relationships and +enable sophisticated reasoning about connected information. + +GraphRAG excels when the connections between entities are as important as the +entities themselves. + +## What you'll accomplish today + +- Set up Neo4j Sandbox for graph database experimentation +- Construct a knowledge graph using web search and entity extraction +- Connect Neo4j to your agent for graph-based retrieval +- Understand GraphRAG principles and relationship reasoning +- Use Neo4j developer tools to explore and visualize graph structures + + + This introduces graph database concepts and requires Neo4j Sandbox setup + (free). Graph thinking is different from relational or document databases - + focus on relationships and connections. + + +## Step 1: Understanding GraphRAG + +GraphRAG represents a fundamentally different approach to information retrieval: + +### Traditional RAG and GraphRAG + +**Traditional RAG**: + +- Searches for similar content based on vector embeddings +- Retrieves isolated pieces of information +- Limited understanding of relationships between entities +- Good for finding relevant documents or data points + +**GraphRAG**: + +- Traverses relationships between connected entities +- Retrieves networks of related information +- Understands complex multi-hop relationships +- Excellent for answering questions that require reasoning across connections + +### When to use GraphRAG + +**Ideal for**: + +- Knowledge domains with complex relationships (research, business intelligence) +- Questions requiring multi-step reasoning ("How are X and Y connected?") +- Recommendation systems based on similarity and relationships +- Analyzing networks, hierarchies, and influence patterns +- Connecting disparate pieces of information through shared entities + +**Examples of GraphRAG queries**: + +- "What companies have partnerships with our competitors' suppliers?" +- "How are these research papers connected through shared authors and + citations?" +- "What are the indirect relationships between this customer and our product + roadmap?" + + + **Graph thinking** Instead of asking "What documents contain X?", GraphRAG + asks "What's connected to X, and what does that network tell us?" + + +## Step 2: Set up Neo4j sandbox + +Neo4j Sandbox provides a free, hosted Neo4j instance for learning: + +### Create your Neo4j sandbox + +1. **Visit [sandbox.neo4j.com](https://sandbox.neo4j.com)** and create a free + account +2. **Create a new project** and select "Blank Sandbox" +3. **Note your connection details**: URL, username, and password +4. **Open Neo4j Browser** to start working with your graph database + +### Understanding Neo4j concepts + +- **Nodes** Entities in your graph (People, Companies, Products, Concepts) +- **Relationships** Connections between nodes (WORKS_FOR, COMPETES_WITH, + INFLUENCES) +- **Properties** Attributes of nodes and relationships (name, date, strength) +- **Labels** Categories for nodes (Person, Company, Technology) + +### Basic Cypher syntax + +Cypher is Neo4j's query language for graphs: + +```cypher +// Create nodes +CREATE (p:Person {name: "Alice", role: "Engineer"}) +CREATE (c:Company {name: "TechCorp", industry: "Software"}) + +// Create relationships +MATCH (p:Person {name: "Alice"}), (c:Company {name: "TechCorp"}) +CREATE (p)-[:WORKS_FOR {since: 2020}]->(c) + +// Query patterns +MATCH (p:Person)-[:WORKS_FOR]->(c:Company) +RETURN p.name, c.name +``` + +## Step 3: Construct knowledge graph using web search + +You'll build a knowledge graph by extracting entities and relationships from web +research: + +### Create a technology company knowledge graph + +Let's build a graph about AI companies and their relationships: + +```cypher +// Create AI companies +CREATE (openai:Company {name: "OpenAI", founded: 2015, industry: "AI Research"}) +CREATE (anthropic:Company {name: "Anthropic", founded: 2021, industry: "AI Safety"}) +CREATE (google:Company {name: "Google", founded: 1998, industry: "Technology"}) +CREATE (microsoft:Company {name: "Microsoft", founded: 1975, industry: "Technology"}) +CREATE (meta:Company {name: "Meta", founded: 2004, industry: "Social Media"}) + +// Create key people +CREATE (sam:Person {name: "Sam Altman", role: "CEO"}) +CREATE (dario:Person {name: "Dario Amodei", role: "CEO"}) +CREATE (demis:Person {name: "Demis Hassabis", role: "CEO"}) +CREATE (satya:Person {name: "Satya Nadella", role: "CEO"}) +CREATE (mark:Person {name: "Mark Zuckerberg", role: "CEO"}) + +// Create AI models/products +CREATE (gpt4:Product {name: "GPT-4", type: "Language Model", release_year: 2023}) +CREATE (claude:Product {name: "Claude", type: "Language Model", release_year: 2022}) +CREATE (gemini:Product {name: "Gemini", type: "Language Model", release_year: 2023}) +CREATE (copilot:Product {name: "GitHub Copilot", type: "AI Assistant", release_year: 2021}) +CREATE (llama:Product {name: "LLaMA", type: "Language Model", release_year: 2023}) + +// Create relationships - leadership +MATCH (sam:Person {name: "Sam Altman"}), (openai:Company {name: "OpenAI"}) +CREATE (sam)-[:CEO_OF {since: 2019}]->(openai) + +MATCH (dario:Person {name: "Dario Amodei"}), (anthropic:Company {name: "Anthropic"}) +CREATE (dario)-[:CEO_OF {since: 2021}]->(anthropic) + +MATCH (demis:Person {name: "Demis Hassabis"}), (google:Company {name: "Google"}) +CREATE (demis)-[:LEADS_AI_AT {division: "DeepMind"}]->(google) + +MATCH (satya:Person {name: "Satya Nadella"}), (microsoft:Company {name: "Microsoft"}) +CREATE (satya)-[:CEO_OF {since: 2014}]->(microsoft) + +MATCH (mark:Person {name: "Mark Zuckerberg"}), (meta:Company {name: "Meta"}) +CREATE (mark)-[:CEO_OF {since: 2004}]->(meta) + +// Create product relationships +MATCH (openai:Company {name: "OpenAI"}), (gpt4:Product {name: "GPT-4"}) +CREATE (openai)-[:DEVELOPS]->(gpt4) + +MATCH (anthropic:Company {name: "Anthropic"}), (claude:Product {name: "Claude"}) +CREATE (anthropic)-[:DEVELOPS]->(claude) + +MATCH (google:Company {name: "Google"}), (gemini:Product {name: "Gemini"}) +CREATE (google)-[:DEVELOPS]->(gemini) + +MATCH (microsoft:Company {name: "Microsoft"}), (copilot:Product {name: "GitHub Copilot"}) +CREATE (microsoft)-[:DEVELOPS]->(copilot) + +MATCH (meta:Company {name: "Meta"}), (llama:Product {name: "LLaMA"}) +CREATE (meta)-[:DEVELOPS]->(llama) + +// Create business relationships +MATCH (microsoft:Company {name: "Microsoft"}), (openai:Company {name: "OpenAI"}) +CREATE (microsoft)-[:PARTNERS_WITH {investment: "10B", type: "Strategic Partnership"}]->(openai) + +MATCH (google:Company {name: "Google"}), (anthropic:Company {name: "Anthropic"}) +CREATE (google)-[:INVESTS_IN {amount: "300M", round: "Series B"}]->(anthropic) + +// Create competitive relationships +MATCH (openai:Company {name: "OpenAI"}), (anthropic:Company {name: "Anthropic"}) +CREATE (openai)-[:COMPETES_WITH {market: "Enterprise AI"}]->(anthropic) + +MATCH (gpt4:Product {name: "GPT-4"}), (claude:Product {name: "Claude"}) +CREATE (gpt4)-[:COMPETES_WITH {category: "Large Language Models"}]->(claude) + +MATCH (gpt4:Product {name: "GPT-4"}), (gemini:Product {name: "Gemini"}) +CREATE (gpt4)-[:COMPETES_WITH {category: "Large Language Models"}]->(gemini) +``` + +### Add research topics and trends + +```cypher +// Create research areas and trends +CREATE (safety:Topic {name: "AI Safety", importance: "Critical"}) +CREATE (alignment:Topic {name: "AI Alignment", importance: "High"}) +CREATE (multimodal:Topic {name: "Multimodal AI", importance: "High"}) +CREATE (reasoning:Topic {name: "AI Reasoning", importance: "Medium"}) +CREATE (agents:Topic {name: "AI Agents", importance: "High"}) + +// Connect companies to research focus areas +MATCH (anthropic:Company {name: "Anthropic"}), (safety:Topic {name: "AI Safety"}) +CREATE (anthropic)-[:FOCUSES_ON {priority: "Primary"}]->(safety) + +MATCH (anthropic:Company {name: "Anthropic"}), (alignment:Topic {name: "AI Alignment"}) +CREATE (anthropic)-[:FOCUSES_ON {priority: "Primary"}]->(alignment) + +MATCH (openai:Company {name: "OpenAI"}), (agents:Topic {name: "AI Agents"}) +CREATE (openai)-[:FOCUSES_ON {priority: "High"}]->(agents) + +MATCH (google:Company {name: "Google"}), (multimodal:Topic {name: "Multimodal AI"}) +CREATE (google)-[:FOCUSES_ON {priority: "High"}]->(multimodal) + +// Connect products to capabilities +MATCH (claude:Product {name: "Claude"}), (safety:Topic {name: "AI Safety"}) +CREATE (claude)-[:IMPLEMENTS]->(safety) + +MATCH (gpt4:Product {name: "GPT-4"}), (multimodal:Topic {name: "Multimodal AI"}) +CREATE (gpt4)-[:IMPLEMENTS]->(multimodal) +``` + +## Step 4: Connect Neo4j to your agent + +Integrate graph database capabilities with your Hypermode agent: + +### Add Neo4j connection + +1. **Navigate to your agent's connections** in the About section +2. **Add Neo4j connection** with your Sandbox credentials +3. **Test the connection** by running a simple Cypher query + +Refer to the [Neo4j connection documentation](agents/connections/neo4j) for more +information on how to add the Neo4j connection to your Hypermode agent. + +### Create a GraphRAG agent + +Create an agent specialized in graph-based reasoning: + +```text +I want to create a knowledge graph analyst agent that helps users discover relationships and insights from connected data. + +The agent should: +- Query graph databases to find complex relationships between entities +- Explain how different companies, people, and technologies are connected +- Discover indirect relationships and influence patterns +- Provide network analysis and relationship insights +- Help users understand competitive landscapes and partnership networks +- Reason about multi-hop relationships and their implications + +The agent should think like a business intelligence analyst who specializes in relationship mapping and network analysis. +``` + +### Configure GraphRAG patterns + +Add these instructions to enhance graph reasoning: + +```text +Graph Analysis Guidelines: +1. Use Cypher queries to explore relationships between entities +2. Look for both direct and indirect connections (2-3 hops) +3. Identify patterns in networks (clusters, influential nodes, bridges) +4. Explain the significance of relationships, not just their existence +5. Consider relationship strength, direction, and properties +6. Provide visual descriptions of network structures when helpful +7. Connect graph insights to business implications and strategic value +``` + +## Step 5: Explore GraphRAG capabilities + +Test sophisticated graph-based reasoning: + +### Relationship discovery queries + +```text +How are OpenAI and Anthropic connected through their business relationships and competitive positioning? What does this network tell us about the AI industry? +``` + +Your agent should: + +1. **Query direct relationships** between the companies +2. **Explore indirect connections** through shared partners, investors, or + competitors +3. **Analyze the network structure** and identify patterns +4. **Provide strategic insights** based on relationship analysis + +### Multi-hop reasoning + +```text +Find all the ways that Microsoft's investment in OpenAI might influence competition with Google's AI products. Consider indirect effects and network implications. +``` + +This requires: + +- **Multi-step traversal** through the graph +- **Reasoning about implications** of connected relationships +- **Understanding competitive dynamics** through network analysis +- **Identifying strategic advantages** or vulnerabilities + +### Network analysis + +```text +Which companies or people are most central to the AI industry network? Who has the most influence based on their connections? +``` + +This tests: + +- **Centrality analysis** using graph algorithms +- **Influence pattern recognition** based on relationship types +- **Network structure understanding** and strategic positioning +- **Competitive advantage assessment** through connectivity + + + **GraphRAG insight** The most valuable insights often come from discovering + unexpected connections or understanding how influence flows through networks + of relationships. + + +## Step 6: Neo4j developer tools exploration + +Use Neo4j's visualization and analysis tools to understand your graph: + +### Neo4j Browser visualization + +In Neo4j Browser, run these queries to explore your graph visually: + +```cypher +// Visualize the entire company network +MATCH (c:Company)-[r]-(n) +RETURN c, r, n +LIMIT 50 + +// Find the most connected entities +MATCH (n)-[r]-() +RETURN n, count(r) as connections +ORDER BY connections DESC +LIMIT 10 + +// Explore competitive relationships +MATCH (c1:Company)-[:COMPETES_WITH]-(c2:Company) +RETURN c1, c2 + +// Find partnership and investment networks +MATCH path = (c1:Company)-[:PARTNERS_WITH|INVESTS_IN*1..2]-(c2:Company) +RETURN path +``` + +### Graph algorithms for analysis + +```cypher +// Find shortest paths between entities +MATCH path = shortestPath((openai:Company {name: "OpenAI"})-[*]-(meta:Company {name: "Meta"})) +RETURN path + +// Discover communities in the network +CALL gds.louvain.stream('myGraph') +YIELD nodeId, communityId +RETURN gds.util.asNode(nodeId).name AS name, communityId +ORDER BY communityId + +// Calculate centrality scores +CALL gds.pageRank.stream('myGraph') +YIELD nodeId, score +RETURN gds.util.asNode(nodeId).name AS name, score +ORDER BY score DESC +``` + +### Advanced graph patterns + +```cypher +// Find triangular relationships (mutual connections) +MATCH (a:Company)-[:PARTNERS_WITH]-(b:Company)-[:COMPETES_WITH]-(c:Company)-[:INVESTS_IN]-(a) +RETURN a, b, c + +// Discover influence paths +MATCH path = (p:Person)-[:CEO_OF]->(c:Company)-[:DEVELOPS]->(product:Product)-[:COMPETES_WITH]->(other:Product) +RETURN path + +// Find similar companies based on shared relationships +MATCH (c1:Company)-[:FOCUSES_ON]->(topic:Topic)<-[:FOCUSES_ON]-(c2:Company) +WHERE c1 <> c2 +RETURN c1.name, c2.name, collect(topic.name) as shared_interests +``` + +## What you've accomplished + +In 30 minutes, you've mastered GraphRAG fundamentals: + +**Graph database setup**: configured Neo4j Sandbox for graph-based knowledge +storage + +**Knowledge graph construction**: built a comprehensive network of AI industry +relationships + +**GraphRAG implementation**: connected graph reasoning capabilities to your +agent + +**Relationship analysis**: explored multi-hop reasoning and network pattern +discovery + +**Visualization tools**: used Neo4j Browser for graph exploration and analysis + +## The power of GraphRAG + +GraphRAG enables reasoning that traditional RAG can't: + +**Traditional RAG**: "What companies work on AI safety?" → Returns individual +documents about AI safety companies + +**GraphRAG**: "How does Anthropic's focus on AI safety create competitive +advantages through their Google partnership while positioning them against +OpenAI's Microsoft alliance?" → Returns network analysis of competitive +positioning through relationship patterns + +This completes your foundation in context engineering fundamentals. + + + Explore advanced graph data modeling with Dgraph, building sophisticated + knowledge graphs from real-world data sources. + + +## Pro tip for today + +Experiment with graph pattern discovery: + +```text +Using the AI industry knowledge graph we built, help me discover: +1. What unexpected relationships exist between seemingly unrelated entities? +2. Which entities serve as "bridges" connecting different parts of the network? +3. How would adding a new company or partnership change the network dynamics? +4. What competitive advantages emerge from specific relationship patterns? + +Show me both the graph queries and the strategic insights they reveal. +``` + +This develops intuition for thinking in graphs and understanding network +effects. + +--- + +**Time to complete**: ~30 minutes + +**Skills learned** Neo4j setup, knowledge graph construction, GraphRAG +implementation, Cypher querying, network analysis, graph visualization + +**Next**: day 21 - Advanced graph data modeling with Dgraph + + + **Remember** GraphRAG's power lies in understanding that knowledge isn't just + about individual facts, but about how those facts connect to create larger + patterns of meaning and influence. + diff --git a/agents/30-days-of-agents/day-21.mdx b/agents/30-days-of-agents/day-21.mdx new file mode 100644 index 00000000..4514de70 --- /dev/null +++ b/agents/30-days-of-agents/day-21.mdx @@ -0,0 +1,519 @@ +--- +title: "Day 21: Dgraph - Graph Data Modeling for Knowledge Graphs" +sidebarTitle: "Day 21: Dgraph Data Modeling" +description: + "Master advanced graph data modeling with Dgraph. Learn key concepts, load + sample RDF data from news articles, and explore different types of knowledge + graphs including lexical, domain, visual, and geospatial." +--- + + + **Goal**: master advanced graph data modeling concepts with Dgraph + +**Theme**: context engineering week - sophisticated knowledge graph architecture + +**Time investment**: ~25 minutes + + + +Welcome to Day 21! Yesterday you explored GraphRAG with Neo4j. Today you'll +advance to **Dgraph** - a distributed graph database designed for modern +applications. You'll learn sophisticated data modeling concepts and build +knowledge graphs from real-world news data. + +## What you'll accomplish today + +- Understand key Dgraph concepts and architecture +- Load sample RDF data from a news article knowledge graph +- Explore different types of knowledge graphs (lexical, domain, visual, + geospatial) +- Model complex relationships and schema design +- Connect to the hyper-news example project for real-world data + + + This introduces advanced graph database concepts. You'll work with RDF data + formats and sophisticated schema design patterns that differ from traditional + databases. + + +We'll use the [hyper-news project](https://github.com/johnymontana/hyper-news) +as our example - a news article knowledge graph that demonstrates real-world +complexity using data from the New York Times API. + +### Understanding key Dgraph concepts + +Dgraph differs from other graph databases in several important ways: + +#### Dgraph architecture + +Dgraph makes + +- **Distributed by design**: Automatically shards data across multiple nodes +- **ACID transactions**: Full transactional consistency across the distributed + system +- **GraphQL native**: Direct GraphQL support without translation layers +- **Type system**: Strong typing with schema validation + +#### Core concepts + +- **Predicates**: Properties or relationships between nodes (similar to edges) +- **UIDs**: Unique identifiers for nodes (automatically managed) +- **Facets**: Properties on predicates (metadata about relationships) +- **Types**: Schema definitions that group predicates +- **Indexes**: Optimizations for specific query patterns + +#### Graph data modeling + +![hyper-news graph data model](/images/agents/30-days-of-agents/day-21-graph-model.png) + +## Step 1: Create your Hypermode Graph instance + +We'll use the [hyper-news project](https://github.com/johnymontana/hyper-news) +as our example - a news article knowledge graph that demonstrates real-world +complexity using data from the New York Times API. + +### Project structure + +The hyper-news knowledge graph contains: + +- **Articles**: News articles with content, metadata, and relationships +- **Entities**: People, organizations, locations mentioned in articles +- **Topics**: Subject categories and themes +- **Sources**: News outlets and publishers +- **Temporal data**: Publication dates and time-based relationships + +## Create your Hypermode graph + + + + + +Navigate to [Hypermode](https://hypermode.com/login) and sign in. + + + + + +Select the "Develop" tab and click "Create Graph". Give your graph a name and +select "Create Graph". + +![create new graph](/images/agents/30-days-of-agents/day-21-hypermode-1.png) + + + + + +Copy the `dgraph://` connection string, you'll use this to connect to your +Hypermode Graph instance. + +![dgraph connection string](/images/agents/30-days-of-agents/day-21-hypermode-2.png) + + + + + +Navigate to [ratel.hypermode.com](https://ratel.hypermode.com) and connect to +your Hypermode Graph instance using the `dgraph://` connection string + +![connect to graph](/images/agents/30-days-of-agents/day-21-hypermode-3.png) + + + + + +![update graph schema](/images/agents/30-days-of-agents/day-21-ratel-update-schema.png) + +Select "Schema" from Ratel's left navigation, then select "Bulk Edit" and copy +and paste the following graph schema to replace the default schema, then select +"Apply + + + +```dql +: string @index(term) . +: float32vector @index(hnsw(metric:"euclidean")) . +: [uid] @reverse . +: [uid] . +: [uid] . +: datetime . +: default . +: [uid] @reverse . +: default . +: default . +: [uid] @reverse . +: default . +: geo @index(geo) . +: default . +: [uid] . +: default . +: default . +: default . +: default . +: string @index(fulltext) . +: string . +: string @index(sha256) . +: string . +: string @index(exact) @upsert . +type { + dgraph.graphql.schema + dgraph.graphql.xid +} +type { + dgraph.graphql.p_query +} +``` + + + + + + + +Load RDF data into your graph, navigate to the +[Ratel](https://ratel.hypermode.com) interface and connect to your graph using +the Dgraph connection string. Then run the following mutation in Ratel (be sure +to select the Mutate tab): + + + +{/* */} + +```dql +{ + set { + _:89285c4b-ab8b-424c-9563-3236d425c2c8 "Article" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "The Scammer's Manual: How to Launder Money and Get Away With It" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "Documents and insiders reveal how one of the world's major money laundering networks operates." . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "nyt://article/6ff00f2a-405a-5b74-99e6-f98f9a409884" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "https://www.nytimes.com/2025/03/23/world/asia/cambodia-money-laundering-huione.html" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "2025-03-23"^^ . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 "[-0.00092336035, 0.08019862, -0.20520164, -0.02801375, 0.0619933, -0.023047846, -0.024484178, 0.020529592, -0.019200675, -0.015409428, -0.056252223, 0.0053777467, 0.08128055, -0.016721966, 0.046918496, -0.04687526, -0.04218578, -0.028148863, -0.042824, 0.020917423, -0.054316618, -0.032370504, -0.028675629, 0.03997199, 0.08500988, 0.017144531, -0.024979042, -0.067222975, 0.004198151, -0.06910834, 0.02121037, -0.078714, -0.053253673, -0.021370014, -0.07213128, -0.02874543, 0.055938214, 0.034668747, -0.02257444, 0.015734173, 0.002615116, 0.037297964, -0.067191556, -0.07372232, 0.0028610034, -0.007968908, 0.0040147076, -0.01675361, 0.04276194, -0.07062117, -0.013656893, 0.069650106, 0.028920174, 0.044660687, 0.031548288, -0.037835848, -0.0064255716, 0.028911343, 0.0009169275, -0.075062, 0.087536186, 0.036825977, -0.007732731, 0.042635478, 0.024788087, -0.038203984, -0.023310525, 0.021034213, 0.00862608, -0.028094534, 0.038340803, -0.007804469, 0.019761235, -0.00019656407, 0.009244875, -0.0032964468, -0.008558698, 0.0132178115, 0.008608392, 0.064217165, 0.046111107, 0.041003242, 0.04581497, 0.020273658, 0.031235896, 0.037693854, -0.013772649, -0.057372384, -0.029200299, 0.053801484, 0.05163047, 0.0047667134, 0.037192836, 0.00623493, -0.02796813, 0.007358853, -0.035745107, 0.01275867, -0.068552606, 0.018099979, -0.020371858, -0.0604366, 0.02112771, 0.021530883, 0.0660968, 0.04888558, 0.009426717, -0.010862091, -0.002711214, 0.013900116, -0.0012326023, 0.020527879, -0.014266488, 0.03844581, 0.008625611, -0.01873364, 0.066690415, 0.0015498915, 0.009729749, 0.058517713, -0.017636323, -0.053251754, -0.023646954, 0.035909656, 0.069451794, 0.016912527, -0.02761872, 0.0029756494, 0.014486133, -0.012998973, 0.02205689, 0.0031078763, -0.010682541, -0.028948735, 0.04719423, 0.077531666, -0.03247138, -0.020979341, -0.031888198, 0.041427974, 0.030766841, 0.002485652, -0.011419673, -0.00673966, -0.023038143, -0.05797337, 0.04556867, 0.0015720715, -0.031727538, -0.018073529, -0.016680855, 0.037625983, -0.04260436, -0.010235528, -0.015568282, -0.030205876, 0.012808569, -0.03778036, 0.042217124, 0.058812555, 0.025896199, -0.017201565, -0.021295544, 0.049216032, -0.035258055, -0.03243178, 0.014102597, 0.0703021, 0.020382358, 0.024729572, -0.021165065, -0.01659005, -0.064313434, 0.010731041, 0.035184678, 0.0056777354, 0.020912189, -0.02150295, 0.07346336, -0.035706487, 0.023945468, -0.026387697, 0.03752386, 0.011889463, 0.0053924406, 0.009470379, 0.0002595008, -0.058607556, 0.032467753, -0.0790825, -0.025970004, 0.031038005, -0.014906579, -0.018815886, -0.009827676, -0.0027572436, 0.013217778, 0.005055923, 0.06915567, -0.06889581, -0.041622456, -0.015985116, -0.041358333, 0.023209602, 0.016503107, 0.026923068, -0.00042518275, 0.032977626, -0.0072815083, 0.04653621, 0.080644496, -0.03536173, 0.010074264, -0.0069507305, 0.0271821, 0.0039338847, -0.00079465157, 0.0052043544, -0.009887138, -0.0049203816, -0.0019415795, 0.011910781, 0.071534336, -0.0052370583, 0.02462654, -0.0096801305, -0.06351153, -0.057395328, -0.024206541, 0.012500014, -0.040890157, -0.090973295, 0.027518911, 0.049901217, -0.026148353, -0.011612191, 0.0130564375, 0.043747183, -0.015552951, 0.043537293, -0.013374157, 0.0017572222, -0.0826361, -0.045705117, -0.04189465, 0.015048251, -0.01184995, -0.04249196, -0.011480411, 0.032527987, 0.023902439, -0.028324336, 0.04576082, 0.010670752, 0.015860224, -0.049910758, -0.029140323, 0.03384373, 0.014318717, 0.017532011, 0.016961541, -0.013189144, 0.06977469, -0.030133663, -0.013400961, -0.06195383, -0.01763788, -0.00073777395, 0.014173, -0.020227041, -0.002678048, 0.03331537, -0.017337443, 0.029439004, -0.02108535, 0.0019703307, 0.0033391328, -0.032127813, -0.06741484, 0.033954434, -0.06429553, -0.0028248366, -0.007518107, -0.04252335, -0.008083261, 0.005591775, 0.042388357, 0.037710037, 0.015690051, 0.011415067, 0.045998093, 0.023077747, 0.022285031, 0.007848019, 0.02653441, -0.028178923, 0.064425625, 0.019558094, 0.006392563, -0.061338507, 0.019965772, 0.027877463, 0.031860583, 0.08822621, 0.0021118685, -0.013568788, 0.012213977, 0.011794686, 0.011746287, -0.04255532, -0.031801987, -0.009595038, 0.0044615394, -0.002963593, -0.022992183, 0.032160193, 0.036371764, 0.018271908, 0.034596313, 0.032899648, -0.008284464, 0.017361738, -0.0075536575, -0.062124927, -0.040073045, 0.010940779, -0.035344217, -0.03577145, -0.044543967, -0.028875787, -0.0077759298, -0.0059001166, 0.026630562, -0.056429848, -0.018643763, 0.045417435, 0.015638778, 0.05498249, -0.015287093, 0.032274425, 0.059427407, -0.007727988, -0.041915257, -0.06761483, -0.015008637, -0.011633817, -0.04473641, 0.010761395, 0.04737682, 0.020224057, -0.039018407, -0.023809792, -0.0315297, -0.045886453, 0.027362607, -0.06854348, 0.02782585, 0.041447368, 0.03809086, -0.032552384, 0.058733862, -0.014951105, 0.03515661, -0.028550006, 0.004903542, 0.047009293, 0.08951287, -0.05251088, 0.0056321933, 0.02853476, -0.017408922, -0.0007259677, 0.01570457, 0.05601831, 0.00045348034, 0.033282496, -0.06320938, -0.003964976, -0.0066398317, 0.044095527, 0.02724642, -0.0070754625, -0.010164292, 0.022364479, 0.026957694, 0.011359415, -0.00507983, -0.042396206, 0.02793773, 0.013252221, -0.012907043, 0.012618729, -0.03461427, -0.0480666, 0.014978358, -0.019859375, 0.017425848, 0.03661084, 0.004448306, 0.011517026, -0.018720599, -0.035887994, -0.038497705, -0.028822478, -0.006980379, 0.05472221, -0.04450025, -0.05632212, 0.045090903, 0.004140744, 0.030121047, 0.068631604, -0.018199425, -0.04147701, 0.0013565508, 0.0387545, 0.0010663066, -0.016067801, -0.011043612, -0.014498814, 0.041405533, 0.025963515, 0.0022729675, -0.027385194, -0.045072332, 0.014473708, 0.054770585, 0.04293996, -0.04913008, -0.045752753, -0.014389631, 0.02197701, 0.02710036, -0.0025271992, -0.015185406, -0.005807928, 0.032912966, 0.0006084796, -0.0029794278, 0.08321632, 0.016833676, -0.022266852, -0.027260445, -0.042198524, 0.056657296, 0.059921164, 0.042768054, 0.0024016933, -0.061421957, 0.011560237, -0.017120233, -0.0030691596, 0.00937358, 0.037908707, 0.0679356, -0.04137055, 0.055778105, -0.027445912, -0.001642649, -0.016804658, 0.008598339, 0.028056495, -0.052670244, 0.021219566, 0.007842755, -0.028742116, 0.0019134064, -0.011207349, 0.022336535, 0.05224679, -0.045004237, 0.053058077, -0.004145731, 0.020089436, 0.013568293, -0.035345018, -0.021599242, 0.029634938, -0.0030767056, 0.0686824, 0.043787353, 0.019378748, -0.041557625, -0.033745863, 0.00733813, 0.039741762, 0.004618008, -0.024221482, -0.0023694562, -0.012751473, -0.034096964, 0.015345173, 0.02447983, -0.0373734, -0.02011196, -0.048121143, 0.008796358, -0.041615844, 0.01688993, 0.030263092, 0.064987145, 0.046141334, -0.045482814, -0.0042524887, 0.057846647, -0.030249111, 0.02020339, -0.025006311, -0.040750742, -0.021008646, -0.06500083, 0.0048085167, -0.046050336, 0.0054290835, 0.052986104, -0.05343075, 0.01965922, 0.0053141345, 0.0042541022, 0.047251824, -0.03221435, 0.016750986, -0.00782761, 0.008853598, -0.05310723, -0.0019603225, -0.008194657, -0.009547082, 0.009860242, -0.017178293, 0.0057994653, 0.043968532, -0.03219604, 0.005740256, 0.04186425, 0.0028427385, 0.015410917, 0.036574762, 0.028851394, 0.05251656, 0.044300422, -0.00097071595, -0.017772328, 0.0455604, 0.032544456, -0.04255213, 0.02168945, 0.004174097, -0.010517134, -0.05498138, 0.02181252, -0.02523621, 0.017497573, -0.024966814, 0.035447225, -0.018723119, 0.03550715, 0.03292103, -0.049964573, -0.017485676, -0.0026190714, 0.010797091, 0.07539779, -0.00016223868, -0.003050531, -0.0030678746, -0.042440422, 0.0101693515, 0.023200147, 0.023714352, -0.0064566624, -0.041058153, -0.057399467, -0.026196888, -0.0050000492, 0.009607953, 0.014601306, 0.001973055, -0.024421114, -0.0732341, 0.028464071, -0.061172992, 0.0232216, 0.019396607, 0.03719588, 0.0111135235, -0.05751737, -0.014568351, 0.012197814, -0.045055896, 0.0032212588, 0.05991664, 0.035642795, -0.04810081, 0.016432445, 0.0027162533, -0.0044268565, 0.01705664, -0.027747115, -0.06991077, -0.033055726, 0.016111575, 0.024187468, -0.06343779, 0.024146182, 0.019591013, 0.052808408, 0.030370824, -0.010137371, -0.006190875, 0.043305665, -0.0165903, -0.034973886, -0.062047835, 0.053061135, -0.027758272, 0.020876635, 0.0036199368, 0.00879301, -0.021009615, -0.029611062, -0.04211273, 0.04090435, -0.04021969, 0.028844664, -0.012987946, -0.0564927, -0.07249975, -0.0259275, 0.04196351, -0.03435903, 0.05718409, -0.030328413, -0.08229106, -0.055770762, 0.03630975, -0.034760907, 0.00054879417, 0.021047873, 0.072642975, 0.034297425, -0.04290415, 0.0116295945, 0.04317626, 0.025564436, -0.009465236, -0.007362335, 0.07016368, 0.048913628, -0.0051406906, 0.062317465, 0.0032403183, 0.014619263, -0.01384008, -0.017416125, -0.053162854, 0.043165516, -0.01638602, -0.06531059, -0.048403855, -0.021571305, 0.034827694, 0.015485262, 0.010537887, 0.037235845, -0.027256703, 0.01626456, -0.0027154225, -0.0979388, -0.0068774517, 0.002590695, -0.005167225, 0.031932924, -0.016133144, -0.029611679, 0.028033081, 0.069326274, -0.0000070652745, -0.020393176, -0.0063950093, 0.023815803, 0.07099068, 0.050766762, -0.040337384, -0.001003275, -0.0652714, -0.0052209944, -0.02312912, 0.013849191, -0.026310049, -0.023425013, -0.04465653, -0.009056439, -0.047710303, 0.0593378, 0.054269917, -0.03018837, -0.009661419, -0.078084394, 0.029557053, -0.009751387, 0.03599116, 0.014580041, 0.049669903, -0.017366845, -0.01187832, 0.031961273, 0.014016153, 0.031833317, -0.0029964242, -0.010907685, -0.03270562, -0.017315654, 0.018068928, 0.010936387, 0.007036878, -0.02308606, -0.04356114, -0.012266045, 0.009524769, 0.054658215, 0.020560471, -0.06412476, -0.04694482, -0.014909701, 0.024904164, 0.05259251, -0.012254937, -0.0048896796, -0.0072809425, -0.015564722, -0.0017214327, -0.02432279, -0.005291404, -0.0055601713, 0.008851829, -0.049824335, -0.034753803, -0.033773642, -0.05969345, -0.05878465, 0.021867614, -0.02654156, -0.030088758, -0.004052159, -0.0037078303, 0.018328678, 0.017710697, -0.0069703492, -0.025681809, 0.059779778, 0.007263781, 0.030907065, 0.022000073, 0.010014955, 0.02152092, -0.023167983, 0.035864413, 0.12227517, 0.03313528, 0.027485542, -0.016374348, 0.00008891975, 0.023746016, -0.022095548, -0.0589547, 0.0007231653, 0.00043499618 ]" . +_:bd5ff24a-4ec2-4066-9652-5171f57ef771 "Author" . +_:bd5ff24a-4ec2-4066-9652-5171f57ef771 "Selam Gebrekidan" . +_:bd5ff24a-4ec2-4066-9652-5171f57ef771 _:89285c4b-ab8b-424c-9563-3236d425c2c8 . +_:e2476b0a-133c-4685-a8d8-a1b98236c346 "Author" . +_:e2476b0a-133c-4685-a8d8-a1b98236c346 "Joy Dong" . +_:e2476b0a-133c-4685-a8d8-a1b98236c346 _:89285c4b-ab8b-424c-9563-3236d425c2c8 . +_:824a5abb-4454-4115-a940-7dee8fa0fc60 "Author" . +_:824a5abb-4454-4115-a940-7dee8fa0fc60 "Chang W. Lee" . +_:824a5abb-4454-4115-a940-7dee8fa0fc60 _:89285c4b-ab8b-424c-9563-3236d425c2c8 . +_:e2cdac1e-7a47-4cd8-8fd9-897bd20f1c80 "Author" . +_:e2cdac1e-7a47-4cd8-8fd9-897bd20f1c80 "Weiyi Cai" . +_:e2cdac1e-7a47-4cd8-8fd9-897bd20f1c80 _:89285c4b-ab8b-424c-9563-3236d425c2c8 . +_:11e2c957-ab09-47cb-9754-150657c615ba "Topic" . +_:11e2c957-ab09-47cb-9754-150657c615ba "Frauds and Swindling" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:11e2c957-ab09-47cb-9754-150657c615ba . +_:ffaa96d6-5af6-466c-8c2b-0151790b671b "Topic" . +_:ffaa96d6-5af6-466c-8c2b-0151790b671b "Money Laundering" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:ffaa96d6-5af6-466c-8c2b-0151790b671b . +_:938fce1b-f6de-4caf-aef0-a5e9dcc06d68 "Topic" . +_:938fce1b-f6de-4caf-aef0-a5e9dcc06d68 "Banking and Financial Institutions" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:938fce1b-f6de-4caf-aef0-a5e9dcc06d68 . +_:73a8ba4b-cc46-4f8d-9d8b-8db5742ee8a9 "Topic" . +_:73a8ba4b-cc46-4f8d-9d8b-8db5742ee8a9 "Robberies and Thefts" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:73a8ba4b-cc46-4f8d-9d8b-8db5742ee8a9 . +_:fb47eee6-1f37-4ba9-b3a3-c8c745a95b6a "Topic" . +_:fb47eee6-1f37-4ba9-b3a3-c8c745a95b6a "Virtual Currency" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:fb47eee6-1f37-4ba9-b3a3-c8c745a95b6a . +_:7207a7e0-6e79-4c43-98cc-e42f683f3b0a "Topic" . +_:7207a7e0-6e79-4c43-98cc-e42f683f3b0a "Computers and the Internet" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:7207a7e0-6e79-4c43-98cc-e42f683f3b0a . +_:4f995f34-7696-410d-b078-a4d1ee148a97 "Topic" . +_:4f995f34-7696-410d-b078-a4d1ee148a97 "audio-neutral-immersive" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:4f995f34-7696-410d-b078-a4d1ee148a97 . +_:d7adb31c-8e55-4fa9-ab43-a459ced1029d "Topic" . +_:d7adb31c-8e55-4fa9-ab43-a459ced1029d "audio-neutral-suspenseful" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:d7adb31c-8e55-4fa9-ab43-a459ced1029d . +_:a26e6f17-c097-4eed-95fe-7aeb2c69d437 "Organization" . +_:a26e6f17-c097-4eed-95fe-7aeb2c69d437 "Huione Group" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:a26e6f17-c097-4eed-95fe-7aeb2c69d437 . +_:0f2945ba-37bb-4ff9-affe-252050811d67 "Organization" . +_:0f2945ba-37bb-4ff9-affe-252050811d67 "Tether Operations Ltd" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:0f2945ba-37bb-4ff9-affe-252050811d67 . +_:161a05a2-81ea-4863-b982-fe48325f45de "Organization" . +_:161a05a2-81ea-4863-b982-fe48325f45de "Telegram LLC" . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:161a05a2-81ea-4863-b982-fe48325f45de . +_:282dca5c-dd1b-49f6-9919-4c9c42d4845f "Geo" . +_:282dca5c-dd1b-49f6-9919-4c9c42d4845f "Phnom Penh (Cambodia)" . +_:282dca5c-dd1b-49f6-9919-4c9c42d4845f "{'type':'Point','coordinates':[104.9282,11.5564]}"^^ . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:282dca5c-dd1b-49f6-9919-4c9c42d4845f . +_:e7bd6a4e-3d86-4cf1-a226-61cd3a89c278 "Geo" . +_:e7bd6a4e-3d86-4cf1-a226-61cd3a89c278 "Cambodia" . +_:e7bd6a4e-3d86-4cf1-a226-61cd3a89c278 "{'type':'Point','coordinates':[104.9910,12.5657]}"^^ . +_:89285c4b-ab8b-424c-9563-3236d425c2c8 _:e7bd6a4e-3d86-4cf1-a226-61cd3a89c278 . +_:2ec51336-568e-4c86-8d77-1592afa83611 "Image" . +_:2ec51336-568e-4c86-8d77-1592afa83611 "Huione is a constellation of affiliates. The headquarters of one of its companies, Huione Pay, is in Phnom Penh, Cambodia." . +_:2ec51336-568e-4c86-8d77-1592afa83611 "https://static01.nyt.com/images/2025/03/10/multimedia/00int-moneylaundering-03-hpgl/00int-moneylaundering-03-hpgl-thumbStandard.jpg" . +_:2ec51336-568e-4c86-8d77-1592afa83611 _:89285c4b-ab8b-424c-9563-3236d425c2c8 . +_:Article_100000010064414 "Article" . +_:Article_100000010064414 "It’s Trump vs. the Courts, and It Won’t End Well for Trump" . +_:Article_100000010064414 "The judiciary will never surrender to the president its constitutional role to interpret the Constitution." . +_:Article_100000010064414 "[0.05038249120116234, 0.058795228600502014, -0.11216231435537338, -0.021286925300955772, 0.04817740619182587, 0.0414428673684597, -0.04697953537106514, 0.037348028272390366, -0.011797518469393253, -0.020323075354099274, 0.0017164889723062515, -0.01714685745537281, 0.021885693073272705, 0.04376671463251114, 0.04797733202576637, -0.01547605823725462, 0.02192000113427639, -0.02175835520029068, 0.002948863198980689, 0.006321301683783531, -0.04765839874744415, -0.001094080857001245, -0.02511022984981537, 0.04317215085029602, 0.08050080388784409, 0.05602758377790451, 0.03712429106235504, -0.025082381442189217, -0.013643899001181126, 0.024736950173974037, -0.007877232506871223, 0.05271192267537117, 0.019025910645723343, -0.023699987679719925, 0.04814165458083153, -0.08723080903291702, 0.05971049889922142, 0.007902886718511581, 0.03182042017579079, -0.04329095780849457, -0.0647377073764801, -0.010789471678435802, -0.083918996155262, -0.043435581028461456, 0.08296576887369156, -0.033632297068834305, 0.060239460319280624, 0.05735386908054352, 0.03676137700676918, -0.019326206296682358, 0.022676490247249603, -0.09239562600851059, 0.04570508375763893, -0.019836582243442535, 0.061863817274570465, 0.07597476243972778, 0.017045240849256516, 0.0498955175280571, -0.040841151028871536, 0.01170419529080391, 0.09735319018363953, -0.00849493034183979, -0.05664645880460739, 0.03504382446408272, -0.008737048134207726, 0.01733621582388878, -0.032963432371616364, 0.046866267919540405, 0.006506554316729307, -0.014955011196434498, 0.039385631680488586, 0.0008437118376605213, -0.004841649904847145, -0.024966398254036903, 0.04792783036828041, -0.03044090047478676, 0.014011336490511894, -0.01905972696840763, -0.04364760220050812, -0.016419796273112297, 0.03227745369076729, -0.06663628667593002, 0.045762546360492706, -0.023100202903151512, 0.0024865821469575167, -0.010295139625668526, 0.011217073537409306, 0.010327308438718319, -0.032288603484630585, 0.1056782454252243, 0.014712595380842686, 0.033389922231435776, 0.03636026382446289, 0.02809780277311802, -0.024538181722164154, -0.017350109294056892, 0.00914673786610365, 0.008687303401529789, -0.03622390702366829, -0.006120243575423956, -0.048699501901865005, -0.023038093000650406, 0.02137245610356331, -0.018966689705848694, 0.04694816470146179, 0.01561683602631092, 0.052321940660476685, 0.022184697911143303, 0.01711142435669899, -0.04968259111046791, -0.052845682948827744, 0.058768659830093384, -0.013000226579606533, -0.007689858786761761, -0.0008546947501599789, -0.007615725975483656, 0.0523887537419796, -0.052580323070287704, 0.005650855600833893, 0.02242126874625683, 0.007889088243246078, 0.007340617943555117, -0.012117046862840652, -0.005830872338265181, -0.038269203156232834, 0.016449380666017532, -0.023527739569544792, 0.04016977921128273, -0.024063676595687866, -0.06637314707040787, -0.06640496104955673, 0.004637458827346563, -0.03460118919610977, 0.034495968371629715, 0.043583836406469345, 0.017685893923044205, 0.007280079182237387, -0.03072427213191986, 0.008505169302225113, 0.03463548794388771, -0.02699446678161621, 0.004232228267937899, 0.03595457226037979, 0.04475175589323044, 0.003940397407859564, -0.041795384138822556, 0.08309721946716309, -0.04651130735874176, -0.0179553534835577, -0.016547197476029396, 0.03209727630019188, 0.0439239963889122, -0.02459815889596939, 0.026868589222431183, 0.026411838829517365, -0.052671339362859726, 0.024068176746368408, 0.0058274115435779095, 0.0018858280964195728, 0.0059128995053470135, 0.06166921928524971, 0.010814705863595009, -0.030825752764940262, 0.048038456588983536, -0.05551855266094208, -0.00420160498470068, 0.010119279846549034, 0.0397237129509449, 0.01743854023516178, 0.02840823493897915, -0.05217785760760307, -0.0028160109650343657, -0.028237177059054375, 0.055129896849393845, 0.0728059783577919, -0.022510355338454247, -0.024135567247867584, -0.024542905390262604, 0.024327557533979416, -0.03793802857398987, 0.044758930802345276, -0.03508693352341652, 0.00999172031879425, -0.029989011585712433, -0.01564241573214531, 0.02924221009016037, 0.02445463463664055, 0.028683403506875038, 0.021463626995682716, -0.006096207536756992, -0.006636155769228935, -0.004264455754309893, -0.0074067553505301476, 0.007472366094589233, -0.020413756370544434, -0.02916806936264038, 0.01665566861629486, 0.04013733193278313, -0.018470995128154755, -0.02998230792582035, -0.03246713802218437, -0.03073200024664402, 0.010016419924795628, -0.011534568853676319, -0.040116194635629654, 0.010491706430912018, -0.027949964627623558, 0.00996584165841341, -0.09300166368484497, -0.0037628766149282455, 0.07623939961194992, -0.004190622363239527, 0.012201444245874882, -0.02054835855960846, 0.04755444452166557, -0.038993943482637405, 0.021817760542035103, -0.03944282978773117, 0.022789612412452698, 0.05862411484122276, -0.00909154862165451, 0.02118791453540325, 0.02693791873753071, -0.06342943757772446, -0.0006572428392246366, -0.014406759291887283, -0.04625315219163895, -0.03271813690662384, 0.006573909427970648, 0.012736557051539421, 0.03653808310627937, -0.07507583498954773, 0.06453768908977509, 0.03914172574877739, -0.05687256529927254, 0.012534432113170624, 0.026428574696183205, 0.011032231152057648, 0.05347106233239174, 0.0031873006373643875, -0.06171061098575592, 0.007092044688761234, 0.019716637209057808, -0.05124755576252937, -0.027481745928525925, 0.020125150680541992, 0.018131816759705544, -0.08442474901676178, 0.027564380317926407, 0.022869231179356575, 0.06489279121160507, 0.017441434785723686, 0.02600848488509655, 0.02943369559943676, -0.000572650576941669, -0.07110941410064697, 0.015273635275661945, -0.007780193816870451, -0.021677719429135323, -0.09940658509731293, 0.030053522437810898, -0.054057493805885315, 0.02906983159482479, -0.03224460408091545, -0.013242591172456741, -0.05494881421327591, 0.032036878168582916, 0.02765725553035736, -0.0028018581215292215, -0.07974174618721008, 0.015735609456896782, 0.09462333470582962, 0.031219003722071648, 0.08168164640665054, 0.02342136949300766, 0.03194839134812355, -0.03858589008450508, -0.020989542827010155, -0.03506401926279068, -0.0348326750099659, -0.030951546505093575, 0.027690252289175987, -0.031093187630176544, -0.03259289637207985, 0.0072990963235497475, -0.02033178135752678, 0.008813376538455486, 0.012775355018675327, -0.01250151265412569, 0.008187174797058105, -0.0023697877768427134, 0.02982313744723797, -0.03918955475091934, 0.032010577619075775, -0.021396396681666374, 0.04638639837503433, 0.021916968747973442, -0.015348323620855808, 0.040150489658117294, -0.048670362681150436, 0.025582414120435715, 0.0026649748906493187, 0.0022588407155126333, 0.02771640755236149, -0.05871456488966942, -0.0011070889886468649, 0.019556833431124687, 0.015401728451251984, 0.06938262283802032, -0.007585637737065554, -0.0481351874768734, -0.00110055529512465, 0.024595344439148903, -0.02971971221268177, -0.07961209118366241, 0.003501464147120714, -0.0008602032903581858, 0.011136336252093315, 0.04647476598620415, 0.018537059426307678, 0.018796183168888092, 0.03901093825697899, -0.01730465516448021, -0.050305720418691635, 0.004829796031117439, 0.06565339118242264, -0.013151961378753185, 0.029650012031197548, -0.04580234736204147, -0.026646384969353676, 0.021755924448370934, 0.0428791381418705, 0.058355867862701416, 0.021115195006132126, -0.0016149693401530385, 0.011977804824709892, -0.003629880491644144, -0.030544724315404892, 0.019788900390267372, 0.031313616782426834, 0.09668336808681488, -0.03805971518158913, 0.02627474255859852, 0.006774241104722023, 0.029789479449391365, -0.005834420211613178, -0.0010006697848439217, -0.007588276173919439, -0.015628529712557793, -0.009973129257559776, 0.018383167684078217, -0.00014107412425801158, 0.02646421268582344, 0.014242297038435936, 0.024884246289730072, 0.012977246195077896, 0.039141226559877396, 0.01660335063934326, -0.02595776692032814, -0.022408541291952133, -0.0030090908985584974, -0.015095042996108532, 0.04122914746403694, 0.0077318004332482815, 0.00600758520886302, 0.02754615806043148, 0.015942417085170746, 0.03188956528902054, 0.02160094678401947, 0.02226310595870018, -0.06262847781181335, -0.019053766503930092, 0.037759050726890564, 0.005418005399405956, 0.011238254606723785, -0.04758363217115402, -0.02071199007332325, -0.017017502337694168, 0.015075252391397953, -0.018464231863617897, 0.034438181668519974, -0.010117633268237114, -0.011959169991314411, -0.013364541344344616, 0.04652421176433563, -0.031502433121204376, 0.024947652593255043, -0.03725329414010048, -0.028422845527529716, -0.0036945154424756765, -0.020497895777225494, -0.009818361140787601, -0.03988558426499367, 0.02258661389350891, -0.015131406486034393, -0.04237306863069534, -0.020223967730998993, 0.012813649140298367, -0.011941546574234962, -0.03589385002851486, -0.008790423162281513, -0.06319613009691238, -0.020607881247997284, -0.00388156995177269, 0.0028946620877832174, 0.04707051441073418, 0.005329711828380823, -0.08094963431358337, -0.027785882353782654, -0.017540251836180687, 0.04216675087809563, 0.020547965541481972, -0.0313473716378212, -0.015363886021077633, 0.05321437120437622, -0.00994417816400528, 0.028447570279240608, 0.014380505308508873, -0.0018638515612110496, 0.013458986766636372, 0.0637432187795639, 0.04285871237516403, 0.0356140062212944, 0.008157864212989807, 0.03915967419743538, -0.0018778559751808643, 0.008501824922859669, 0.02671061083674431, -0.012386936694383621, -0.02181047946214676, -0.0050231050699949265, -0.025384478271007538, 0.0655684694647789, -0.0295538492500782, -0.03638719394803047, -0.021702473983168602, -0.0247305016964674, -0.004432926885783672, -0.029824620112776756, 0.10686944425106049, 0.02722608484327793, -0.05778251215815544, -0.05013261362910271, 0.01871374249458313, 0.007663625292479992, 0.07527028024196625, 0.022271733731031418, 0.04499734193086624, -0.03681841865181923, -0.06281627714633942, 0.015319202095270157, 0.002323899883776903, -0.015593198128044605, 0.01050935871899128, 0.04398168995976448, -0.003611965337768197, -0.062292877584695816, 0.008509237319231033, 0.04584096372127533, 0.024243028834462166, -0.023157382383942604, -0.015633881092071533, -0.021108504384756088, 0.05582025274634361, -0.04291731119155884, 0.010924052447080612, -0.010971924290060997, -0.053344786167144775, 0.02897789515554905, 0.02253701351583004, -0.06000944972038269, -0.000788728822953999, 0.041557908058166504, -0.03427810221910477, -0.011103486642241478, -0.03984641283750534, 0.024138672277331352, -0.010788356885313988, 0.05897390469908714, 0.042465344071388245, -0.0024804137647151947, -0.04840341955423355, -0.03582682088017464, -0.034796565771102905, -0.0004399163299240172, 0.06878915429115295, 0.08304701000452042, -0.023558173328638077, -0.016084102913737297, -0.04249172657728195, 0.048878513276576996, 0.031156685203313828, 0.025458622723817825, -0.0057054306380450726, 0.024926038458943367, -0.011081335134804249, -0.03214121237397194, -0.028512511402368546, 0.030801687389612198, 0.03852475434541702, 0.029046641662716866, 0.02671736478805542, -0.00874768104404211, 0.04384639114141464, -0.03427295759320259, -0.019874121993780136, -0.006194400135427713, -0.03637347370386124, -0.06808359175920486, 0.02036312222480774, -0.03429485484957695, -0.007955902256071568, 0.021682875230908394, 0.0716102197766304, 0.06818962842226028, -0.06045995652675629, -0.025537891313433647, 0.018623698502779007, -0.08220860362052917, 0.01673673279583454, 0.015510759316384792, -0.00425098929554224, 0.014149785973131657, -0.0819428414106369, -0.010122752748429775, 0.03757791221141815, 0.050402142107486725, -0.07678540050983429, 0.06142081320285797, 0.017118260264396667, 0.024196457117795944, 0.02589448355138302, -0.023841941729187965, -0.004603979177772999, 0.014954416081309319, 0.016053033992648125, -0.07459896802902222, -0.006217937916517258, 0.04232024401426315, 0.002804424846544862, -0.0009742106194607913, 0.017131956294178963, -0.008973225019872189, 0.02532798796892166, 0.02948184870183468, 0.01445115078240633, -0.06819204241037369, 0.0030644929502159357, -0.04740794375538826, -0.022151771932840347, -0.02877454273402691, 0.00740148825570941, -0.036958467215299606, -0.022518742829561234, 0.049273744225502014, -0.021695896983146667, 0.02548009715974331, -0.033548783510923386, -0.033957019448280334, -0.04511905834078789, 0.01644589565694332, 0.09950347989797592, 0.029682204127311707, 0.0037318626418709755, -0.024713920429348946, -0.056420356035232544, 0.006649395916610956, -0.059271883219480515, -0.027533942833542824, 0.0433354452252388, 0.027225874364376068, -0.06508076190948486, -0.014319908805191517, 0.02032507210969925, -0.014297233894467354, -0.003951805178076029, -0.04910515621304512, -0.059487175196409225, 0.006263994611799717, -0.037078987807035446, 0.0630621388554573, -0.03715026378631592, -0.005171319004148245, 0.0036575556732714176, -0.025611134245991707, 0.0021267232950776815, -0.004813394974917173, 0.02001875638961792, 0.02062581665813923, 0.0558105930685997, -0.0001516431220807135, -0.02491859532892704, 0.010159192606806755, 0.0008590157376602292, -0.030529988929629326, 0.0057417829521000385, 0.0076438188552856445, -0.00665288558229804, -0.0016580213559791446, -0.027736986055970192, -0.0522361621260643, 0.02398715727031231, 0.057094756513834, -0.04685121029615402, 0.01694015972316265, -0.0011215705890208483, 0.01665646955370903, 0.014646478928625584, 0.00659112399443984, -0.0313909687101841, -0.02271713875234127, 0.016802560538053513, -0.020180029794573784, -0.06474654376506805, 0.00842411071062088, -0.00699396338313818, 0.06381089240312576, -0.015864890068769455, -0.06843926757574081, -0.02728293463587761, 0.02541944943368435, -0.00025000033201649785, 0.01574527658522129, 0.02913728542625904, 0.014364532195031643, -0.013126437552273273, -0.05842083692550659, 0.012340355664491653, 0.0506250374019146, 0.010096854530274868, 0.010727216489613056, 0.006305173505097628, -0.00933822337538004, -0.023963838815689087, -0.0370502769947052, -0.03508960083127022, -0.042263735085725784, -0.03748786076903343, -0.010153799317777157, 0.05576179549098015, 0.02584952488541603, 0.028048200532794, 0.010344802401959896, 0.03341485932469368, -0.03994154557585716, 0.025773555040359497, 0.03673772141337395, 0.011175928637385368, -0.013135702349245548, -0.0762358158826828, 0.03418443724513054, 0.03754375874996185, 0.029385406523942947, -0.03219980373978615, -0.008166473358869553, -0.002033072290942073, 0.017162278294563293, -0.03685037046670914, -0.01283805537968874, -0.052200861275196075, 0.05913116782903671, 0.02924790233373642, -0.0012907821219414473, 0.018856579437851906, -0.013996345922350883, -0.018615050241351128, 0.03609275072813034, -0.028826240450143814, -0.050501346588134766, -0.010146462358534336, 0.02554083615541458, -0.018776096403598785, 0.06737877428531647, -0.03390148654580116, 0.02968483790755272, -0.033929530531167984, -0.025306638330221176, 0.014661352150142193, 0.059862952679395676, 0.028974590823054314, -0.03533853963017464, 0.005910288542509079, 0.08462423831224442, -0.03528030961751938, -0.00982168409973383, -0.03216729685664177, 0.05536894127726555, -0.039683155715465546, -0.01244601234793663, -0.04495496302843094, -0.017416859045624733, -0.05886140093207359, 0.029740329831838608, -0.031036866828799248, -0.01986580155789852, 0.002625726629048586, -0.010517681017518044, 0.006570639554411173, -0.018686508759856224, 0.0038424599915742874, -0.024049604311585426, -0.0026526509318500757, -0.009706133976578712, 0.05907558649778366, -0.06307557225227356, -0.024534698575735092, -0.04068480804562569, -0.03774971514940262, -0.03183687478303909, 0.01323347631841898, 0.0041253394447267056, 0.025951143354177475, -0.009037411771714687, 0.06197737529873848, 0.013797340914607048, -0.00910097360610962, -0.03678758069872856, -0.02690425142645836, -0.0013392851687967777, -0.03684156388044357, 0.041437216103076935, -0.040483664721250534, -0.02292501926422119, -0.03657152131199837, -0.060516003519296646, -0.014459939673542976, -0.0021345734130591154, -0.0601021982729435, 0.0019954005256295204, -0.03621481731534004, -0.02448601834475994, -0.004538543522357941, -0.04938667267560959, 0.009435062296688557, -0.061629340052604675, 0.04100124537944794, -0.03157318755984306, 0.02254428341984749, -0.021455809473991394, 0.011723588220775127, -0.05574485659599304, -0.002471092389896512, -0.01781153678894043, 0.045153554528951645, 0.03932283818721771, -0.0329207181930542, -0.029692718759179115, -0.00648312084376812, 0.02915620245039463, -0.019401531666517258, 0.024726372212171555, -0.03170626610517502, -0.0092009911313653, 0.044325634837150574, -0.015496624633669853, -2.2015785361872986e-05, 0.056558385491371155, -0.029567047953605652, 0.11307866871356964, 0.03014186955988407, 0.022086679935455322, -0.019603662192821503, 0.05810973048210144, -0.01710583083331585, -0.011829051189124584, -0.04909808933734894, -0.018814222887158394, 0.029482340440154076]" . +_:Article_100000010064414 "nyt://article/f44c637b-e423-55aa-b0c0-9ee3d8edf387" . +_:Article_100000010064414 "https://www.nytimes.com/2025/03/23/opinion/trump-judge-venezuela-deportation.html" . +_:Article_100000010064414 "2025-03-23"^^ . +_:Author_JMichaelLuttig "Author" . +_:Author_JMichaelLuttig "J. Michael Luttig" . +_:Author_JMichaelLuttig _:Article_100000010064414 . +_:Topic_UnitedStatesPoliticsandGovernment "Topic" . +_:Topic_UnitedStatesPoliticsandGovernment "United States Politics and Government" . +_:Article_100000010064414 _:Topic_UnitedStatesPoliticsandGovernment . +_:Topic_CourtsandtheJudiciary "Topic" . +_:Topic_CourtsandtheJudiciary "Courts and the Judiciary" . +_:Article_100000010064414 _:Topic_CourtsandtheJudiciary . +_:Topic_FederalCourtsUS "Topic" . +_:Topic_FederalCourtsUS "Federal Courts (US)" . +_:Article_100000010064414 _:Topic_FederalCourtsUS . +_:Topic_PresidentialPowerUS "Topic" . +_:Topic_PresidentialPowerUS "Presidential Power (US)" . +_:Article_100000010064414 _:Topic_PresidentialPowerUS . +_:Topic_Deportation "Topic" . +_:Topic_Deportation "Deportation" . +_:Article_100000010064414 _:Topic_Deportation . +_:Topic_IllegalImmigration "Topic" . +_:Topic_IllegalImmigration "Illegal Immigration" . +_:Article_100000010064414 _:Topic_IllegalImmigration . +_:Organization_JusticeDepartment "Organization" . +_:Organization_JusticeDepartment "Justice Department" . +_:Article_100000010064414 _:Organization_JusticeDepartment . +_:Organization_RepublicanParty "Organization" . +_:Organization_RepublicanParty "Republican Party" . +_:Article_100000010064414 _:Organization_RepublicanParty . +_:Organization_SupremeCourtUS "Organization" . +_:Organization_SupremeCourtUS "Supreme Court (US)" . +_:Article_100000010064414 _:Organization_SupremeCourtUS . +_:Person_BoasbergJamesE "Person" . +_:Person_BoasbergJamesE "Boasberg, James E" . +_:Article_100000010064414 _:Person_BoasbergJamesE . +_:Person_HamiltonAlexander "Person" . +_:Person_HamiltonAlexander "Hamilton, Alexander" . +_:Article_100000010064414 _:Person_HamiltonAlexander . +_:Person_MarshallJohn "Person" . +_:Person_MarshallJohn "Marshall, John" . +_:Article_100000010064414 _:Person_MarshallJohn . +_:Person_RobertsJohnGJr "Person" . +_:Person_RobertsJohnGJr "Roberts, John G Jr" . +_:Article_100000010064414 _:Person_RobertsJohnGJr . +_:Person_TrumpDonaldJ "Person" . +_:Person_TrumpDonaldJ "Trump, Donald J" . +_:Article_100000010064414 _:Person_TrumpDonaldJ . +_:38965844-656a-4172-b548-91dcbe9e023e "Image" . +_:38965844-656a-4172-b548-91dcbe9e023e "" . +_:38965844-656a-4172-b548-91dcbe9e023e "https://static01.nyt.com/images/2025/03/21/multimedia/00luttig-wgfj/00luttig-wgfj-thumbStandard.jpg" . +_:38965844-656a-4172-b548-91dcbe9e023e _:Article_100000010064414 . +_:Article_100000009988576 "Article" . +_:Article_100000009988576 "The Scammer’s Manual: How to Launder Money and Get Away With It" . +_:Article_100000009988576 "Documents and insiders reveal how one of the world’s major money laundering networks operates." . +_:Article_100000009988576 "[0.00961915124207735, 0.07751184701919556, -0.2118474245071411, -0.021972330287098885, 0.057156238704919815, -0.0202731154859066, -0.017020752653479576, 0.03639491647481918, -0.005621707066893578, -0.016267752274870872, -0.05293148010969162, -0.010126681067049503, 0.07250042259693146, -0.023925280198454857, 0.045623213052749634, -0.04186142235994339, -0.04304502159357071, -0.025097576901316643, -0.04496070742607117, 0.016891513019800186, -0.07065761834383011, -0.03229387104511261, -0.01308612059801817, 0.036527618765830994, 0.06330248713493347, -0.005751284305006266, -0.029900239780545235, -0.08009859919548035, 0.013764245435595512, -0.05221813917160034, 0.032890435308218, -0.07194230705499649, -0.05712023749947548, -0.03108288161456585, -0.06647130846977234, -0.013517102226614952, 0.04923470690846443, 0.019420651718974113, -0.014028025791049004, 0.019812803715467453, -0.007961602881550789, 0.040302734822034836, -0.0742684155702591, -0.05499899759888649, 0.0007551871822215617, -0.016950709745287895, 0.007561336271464825, -0.019294051453471184, 0.05178140476346016, -0.05403464287519455, -0.015323666855692863, 0.05710078403353691, -0.0034512418787926435, 0.0556379072368145, 0.029124420136213303, -0.044079460203647614, -0.006812221370637417, 0.037481945008039474, -0.0018065761541947722, -0.0801541656255722, 0.08496874570846558, 0.034245315939188004, 0.00020554015645757318, 0.050330206751823425, 0.012106090784072876, -0.024732619524002075, -0.0248411912471056, 0.03664475306868553, 0.020860373973846436, -0.030435387045145035, 0.03843863680958748, -0.015801962465047836, 0.023015905171632767, -0.0016854749992489815, 0.01760799065232277, -0.009927463717758656, -0.018965400755405426, 0.014629902318120003, 0.010007157921791077, 0.06646733731031418, 0.05542993173003197, 0.020191090181469917, 0.026113729923963547, 0.020102815702557564, 0.021069306880235672, 0.03431503847241402, -0.018591616302728653, -0.048364412039518356, -0.034666258841753006, 0.058326564729213715, 0.06404416263103485, 0.010184538550674915, 0.04347497597336769, 0.013428214006125927, -0.03989206627011299, 0.014244183897972107, -0.03220338374376297, 0.028675630688667297, -0.0650133416056633, 0.012817618437111378, 0.0021085434127599, -0.04427453503012657, 0.028098350390791893, 0.012800545431673527, 0.0733502209186554, 0.042314909398555756, 0.029145626351237297, -0.013528008945286274, -0.004642062354832888, 0.026535458862781525, -0.002071481430903077, 0.019693056121468544, -0.013677223585546017, 0.045266225934028625, 0.0012219161726534367, -0.015607824549078941, 0.05734053626656532, 0.007588009815663099, 0.0031283367425203323, 0.04473121836781502, -0.012964907102286816, -0.06996973603963852, -0.03030712530016899, 0.023210469633340836, 0.06962987035512924, 0.026379404589533806, -0.02524801716208458, 0.000773992040194571, 0.005262783728539944, -0.010246852412819862, 0.0004182998090982437, -0.004065764602273703, -0.00994095392525196, -0.03435645252466202, 0.027469640597701073, 0.07097417116165161, -0.042412661015987396, -0.03348338603973389, -0.021559542044997215, 0.043689947575330734, 0.03045741468667984, 0.0016945756506174803, -0.00033138078288175166, 0.0028155685868114233, -0.02652886137366295, -0.06179206445813179, 0.04814790561795235, -0.018100835382938385, -0.026160625740885735, -0.022430332377552986, -0.024131637066602707, 0.03403693437576294, -0.04503524303436279, 0.005425558891147375, -0.00986867118626833, -0.030082106590270996, 0.012519296258687973, -0.026560720056295395, 0.05357349291443825, 0.04410458728671074, 0.013646287843585014, -0.03436680883169174, -0.012221957556903362, 0.03285563364624977, -0.037022665143013, -0.04369169473648071, 0.007167597766965628, 0.07393082976341248, 0.0016578820068389177, 0.02520592510700226, -0.025829270482063293, -0.029058828949928284, -0.07547148317098618, 0.0039641838520765305, 0.0384925901889801, 0.0024611407425254583, 0.016092980280518532, -0.01321965642273426, 0.07636640965938568, -0.028856439515948296, 0.03522363305091858, -0.02584768459200859, 0.038584642112255096, 0.011687809601426125, 0.013304493390023708, 0.017990609630942345, -0.00997051503509283, -0.05184203386306763, 0.038903553038835526, -0.087668277323246, -0.020122123882174492, 0.028842806816101074, -0.01707686483860016, -0.023630738258361816, 0.001390129211358726, -0.002872307086363435, -0.00503362063318491, 0.0127232251688838, 0.07543203234672546, -0.06402827799320221, -0.03191293403506279, -0.022103695198893547, -0.029192540794610977, 0.02090361900627613, 0.02773170731961727, 0.0453663170337677, 0.01342727616429329, 0.016573015600442886, -0.008561813272535801, 0.0360468327999115, 0.0889977514743805, -0.029257453978061676, 0.003304530633613467, -0.009786431677639484, 0.016086716204881668, 0.008326249197125435, -0.005766807124018669, 0.0022251997143030167, -0.017165133729577065, -0.0026251047383993864, 0.004300118889659643, 0.007598059717565775, 0.08201586455106735, -0.014456980861723423, 0.01766645349562168, -0.006121040787547827, -0.07612856477499008, -0.05792873352766037, -0.02180693857371807, 0.013312089256942272, -0.024423861876130104, -0.06896456331014633, 0.034386344254016876, 0.04545734450221062, -0.028259707614779472, -0.01487391721457243, -0.0038134539499878883, 0.03595025837421417, -0.027986526489257812, 0.0458354651927948, -0.022541873157024384, 0.010599303059279919, -0.0941295176744461, -0.03849303722381592, -0.03897751122713089, 0.003465239657089114, -0.012099282816052437, -0.023089425638318062, -0.01693977229297161, 0.03157922253012657, 0.023502575233578682, -0.03278940171003342, 0.0384359247982502, -0.0013598642544820905, 0.010801488533616066, -0.03821505606174469, -0.035099755972623825, 0.041400276124477386, 0.02040908858180046, 0.00579148018732667, 0.008091813884675503, -0.0032242326997220516, 0.06815370172262192, -0.020249733701348305, -0.017481353133916855, -0.049322258681058884, -0.01889844797551632, 0.0005240229074843228, 0.014516675844788551, -0.008749613538384438, -0.0002711733977776021, 0.01927023194730282, -0.008287046104669571, 0.017646262422204018, -0.026921676471829414, 0.013728786259889603, 0.00686973100528121, -0.03723001852631569, -0.07043983042240143, 0.05439385026693344, -0.06785853207111359, 0.001891355263069272, -0.0074833473190665245, -0.04578134045004845, -0.01341241504997015, -0.003900235751643777, 0.046959321945905685, 0.029421361163258553, -0.0008784362580627203, 0.01953306794166565, 0.050895001739263535, 0.021201420575380325, 0.01189956720918417, 0.0036687273532152176, 0.03271525725722313, -0.024085121229290962, 0.06636793911457062, 0.021129174157977104, 0.007365579251199961, -0.05620065703988075, 0.03155935928225517, 0.009481956250965595, 0.02863212674856186, 0.0978347584605217, 0.005369411315768957, -0.01095366571098566, 0.008087263442575932, 0.01981692761182785, 0.014489058405160904, -0.06278949975967407, -0.011960742063820362, -0.000275989412330091, -0.001307618455030024, -0.002622084692120552, -0.01554043684154749, 0.027015922591090202, 0.04784521088004112, 0.00735466368496418, 0.039907924830913544, 0.02239414118230343, -0.015473744831979275, 0.02974540926516056, -0.013642662204802036, -0.054522860795259476, -0.033457379788160324, 0.01186323445290327, -0.021331390365958214, -0.03618095442652702, -0.06130875274538994, -0.03216133266687393, -0.023610321804881096, 0.001189395901747048, 0.01888924650847912, -0.057297419756650925, -0.01062366645783186, 0.03990298882126808, 0.01258351281285286, 0.04568847641348839, -0.018948199227452278, 0.036606766283512115, 0.051359422504901886, -0.006872979458421469, -0.03665727376937866, -0.06275642663240433, -0.030122535303235054, 0.001829583547078073, -0.04690767079591751, 0.01282803900539875, 0.04087992012500763, 0.0254364013671875, -0.03174182027578354, -0.0279832910746336, -0.011128263548016548, -0.04910559952259064, 0.037863656878471375, -0.06493425369262695, 0.01197921484708786, 0.049552660435438156, 0.02305394969880581, -0.022594083100557327, 0.05818929523229599, -0.002735654590651393, 0.02616424486041069, -0.030333131551742554, 0.0034172250889241695, 0.04833132028579712, 0.08150148391723633, -0.045816246420145035, 0.02076355740427971, 0.0280773863196373, -0.01866202801465988, 0.010375759564340115, 0.014574115164577961, 0.057941604405641556, -0.0008631634409539402, 0.05590423196554184, -0.05661485716700554, -0.005179590545594692, 0.009435836225748062, 0.044704001396894455, 0.006479273084551096, -0.003554671537131071, -0.00965220294892788, 0.0005714489961974323, 0.006632519885897636, 0.005947988014668226, -0.01081653032451868, -0.040628787130117416, 0.026921426877379417, 0.020924707874655724, -0.000290124851744622, 0.017990458756685257, -0.028547311201691628, -0.04866660758852959, 0.017264917492866516, -0.020474322140216827, 0.014625140465795994, 0.03167558088898659, 0.025272797793149948, 0.01209953986108303, -0.017308736220002174, -0.04483134299516678, -0.035195447504520416, -0.035613007843494415, 0.0006708086002618074, 0.057962458580732346, -0.06261751800775528, -0.061350565403699875, 0.03543972596526146, -0.009270082227885723, 0.025759825482964516, 0.07567574828863144, -0.008290158584713936, -0.03209218010306358, 0.0025663580745458603, 0.044942814856767654, 0.00931192934513092, 0.002511078491806984, -0.005846492946147919, -0.021095046773552895, 0.0536423921585083, 0.03895355015993118, 0.011556128039956093, -0.011924350634217262, -0.035620931535959244, 0.02860751748085022, 0.04969971626996994, 0.031480301171541214, -0.045802053064107895, -0.03161313757300377, -0.013617363758385181, 0.009831166826188564, 0.03038664534687996, -0.014816981740295887, -0.019100205972790718, -0.007140301633626223, 0.02108062244951725, -0.016044920310378075, 0.002952207811176777, 0.08489999175071716, 0.03359166905283928, -0.03163224086165428, -0.041631441563367844, -0.03197918087244034, 0.03963356837630272, 0.06839071959257126, 0.05659841373562813, 0.020305141806602478, -0.05991426855325699, 0.012651333585381508, -0.011986834928393364, -0.014251192100346088, 0.006389661692082882, 0.03222141042351723, 0.06404533237218857, -0.025733819231390953, 0.05320410802960396, -0.03189397230744362, -0.007628411520272493, -0.0197581946849823, 0.007601141929626465, 0.025782179087400436, -0.039832957088947296, 0.02033354341983795, 0.0010339152067899704, -0.03425801917910576, 0.018575584515929222, -0.01315431110560894, 0.03626828268170357, 0.04669955000281334, -0.0432295985519886, 0.05563889816403389, -0.007047558203339577, 0.027738748118281364, 0.011122340336441994, -0.04257450997829437, -0.01754203997552395, 0.029611432924866676, 0.0026494236662983894, 0.053963448852300644, 0.05213851109147072, 0.019394444301724434, -0.04666690528392792, -0.029682619497179985, -0.0025417073629796505, 0.043553922325372696, 0.015571001917123795, -0.026900213211774826, 0.0033380258828401566, -0.011562691070139408, -0.03809799626469612, 0.013317621313035488, 0.01653544045984745, -0.03022420033812523, -0.02565028890967369, -0.04421127215027809, -0.016597848385572433, -0.0459543839097023, 0.018284093588590622, 0.025167152285575867, 0.05949674919247627, 0.056595828384160995, -0.04587572440505028, -0.01707480102777481, 0.04867714270949364, -0.02030576579272747, 0.016716239973902702, -0.02076064608991146, -0.035335831344127655, -0.005063216667622328, -0.052249133586883545, -0.0016401573084294796, -0.06113724038004875, 0.009827221743762493, 0.04936152696609497, -0.049132395535707474, 0.019346607849001884, 0.005451729986816645, 0.006923553999513388, 0.04209277778863907, -0.028096644207835197, 0.018373874947428703, 0.0028437443543225527, 0.02230113558471203, -0.055678144097328186, -0.00961438100785017, -0.011686642654240131, -0.006761493626981974, 0.012237388640642166, -0.015143916010856628, 0.011241201311349869, 0.04684866964817047, -0.030856603756546974, 0.006922805216163397, 0.035227227956056595, 0.0207511056214571, 0.011575092561542988, 0.026827717199921608, 0.03319241851568222, 0.04111585021018982, 0.05375337973237038, -0.006788127589970827, -0.011991997249424458, 0.060706254094839096, 0.021681534126400948, -0.043537359684705734, 0.031882964074611664, 0.005868036765605211, -0.008436299860477448, -0.04792018234729767, 0.01458408311009407, -0.011307381093502045, 0.004933870397508144, -0.02311914600431919, 0.030535776168107986, -0.02638833597302437, 0.019375033676624298, 0.027088165283203125, -0.053582802414894104, 0.0004066770488861948, -0.0012855735840275884, 0.01806086115539074, 0.08540559560060501, -0.004803819581866264, -0.00821402482688427, 0.014365085400640965, -0.04309416562318802, 0.0030447766184806824, 0.009051733650267124, 0.02868037112057209, -0.00013823497283738106, -0.04970177635550499, -0.06304207444190979, -0.02181728556752205, -0.006745806895196438, 0.015018366277217865, 0.0194927379488945, -0.006965080741792917, -0.018976757302880287, -0.06810754537582397, 0.03701430931687355, -0.04209859296679497, 0.014840620569884777, 0.023390578106045723, 0.03110620006918907, -0.0037461668252944946, -0.051288288086652756, -0.015874149277806282, 0.03071410581469536, -0.04581760987639427, -0.008057706989347935, 0.06118979677557945, 0.020626908168196678, -0.04762501269578934, 0.018225928768515587, -0.026773525401949883, -0.0007960723014548421, 0.012470154091715813, -0.029875285923480988, -0.07165689766407013, -0.03419873118400574, 0.012478811666369438, 0.017982978373765945, -0.061551935970783234, 0.01935802586376667, 0.01927490532398224, 0.06088424101471901, 0.055474113672971725, -0.017734840512275696, -0.001309997751377523, 0.06308315694332123, -0.01920171082019806, -0.03701140731573105, -0.06814407557249069, 0.03068901039659977, -0.037887897342443466, 0.01997082307934761, -0.0038679479621350765, 0.012878837995231152, -0.03605247288942337, -0.042447470128536224, -0.06005585566163063, 0.03703788295388222, -0.034945420920848846, 0.026147661730647087, -0.026105772703886032, -0.058327607810497284, -0.058612506836652756, -0.027565017342567444, 0.05294766649603844, -0.028113920241594315, 0.05236291512846947, -0.018275007605552673, -0.08425755798816681, -0.04396199807524681, 0.019719386473298073, -0.03278883174061775, -0.013445633463561535, 0.011542456224560738, 0.06509555876255035, 0.04803643748164177, -0.0401022844016552, 0.0017988038016483188, 0.0517202690243721, 0.02278948202729225, 0.0008335960446856916, 0.00443787407130003, 0.07076238840818405, 0.0519990511238575, -0.007471687626093626, 0.06894057244062424, 0.014485664665699005, 0.01270509697496891, -0.023908067494630814, -0.02184288203716278, -0.045357171446084976, 0.04366464167833328, -0.012945909053087234, -0.05734879523515701, -0.05435693636536598, -0.02399718575179577, 0.05735364183783531, 0.007531464099884033, 0.009545354172587395, 0.04616665095090866, -0.0194602832198143, 0.020177194848656654, -0.0029073585756123066, -0.10586267709732056, -0.00493124034255743, -0.005821725353598595, 0.00014031729369889945, 0.02878492884337902, -0.021818874403834343, -0.01715104840695858, 0.02524581551551819, 0.07510467618703842, -0.00807313434779644, -0.015898210927844048, 0.009899674914777279, 0.027677105739712715, 0.07317603379487991, 0.030187010765075684, -0.035077281296253204, 0.01506334263831377, -0.04557893052697182, 0.006160695571452379, -0.020929750055074692, 0.004980457480996847, -0.04811522364616394, -0.019872523844242096, -0.02824719250202179, -0.014432284981012344, -0.04463633522391319, 0.06595053523778915, 0.05156726762652397, -0.022946642711758614, -0.021282320842146873, -0.06912046670913696, 0.02681650221347809, -0.012289988808333874, 0.040354423224925995, 0.028368156403303146, 0.03331036865711212, -0.014390945434570312, -0.013395899906754494, 0.023912224918603897, 0.015542503446340561, 0.024598676711320877, -0.001001176773570478, -0.012344755232334137, -0.030800221487879753, -0.017810439690947533, 0.008567790500819683, 0.010117100551724434, -0.0012933425605297089, -0.03617772459983826, -0.04475037753582001, -0.004850700497627258, 0.015027333050966263, 0.06326041370630264, 0.008876025676727295, -0.05728274956345558, -0.03874664008617401, -0.009278367273509502, 0.015093148685991764, 0.059775106608867645, -0.03896361589431763, -0.021855222061276436, -0.02016589045524597, -0.004504490178078413, -0.00022805875050835311, -0.0277190413326025, -0.012456775642931461, 0.0007523685344494879, -0.004988048691302538, -0.04559997469186783, -0.04587370529770851, -0.04316681623458862, -0.07765883952379227, -0.05340832099318504, 0.02397126331925392, -0.04510710760951042, -0.022044314071536064, 0.006461565848439932, -0.0009697407367639244, 0.01966552808880806, 0.021742751821875572, -0.021541954949498177, -0.012771756388247013, 0.062231630086898804, 0.003619229653850198, 0.025890279561281204, 0.027484087273478508, 0.002145038451999426, 0.03811495751142502, -0.024163996800780296, 0.050043318420648575, 0.116086445748806, 0.03278062120079994, 0.036631688475608826, -0.014699306339025497, -0.0004815446154680103, 0.02335752546787262, -0.024495873600244522, -0.05098729580640793, 0.008624924346804619, 0.005866807419806719]" . +_:Article_100000009988576 "nyt://article/6ff00f2a-405a-5b74-99e6-f98f9a409884" . +_:Article_100000009988576 "https://www.nytimes.com/2025/03/23/world/asia/cambodia-money-laundering-huione.html" . +_:Article_100000009988576 "2025-03-23"^^ . +_:Author_SelamGebrekidan "Author" . +_:Author_SelamGebrekidan "Selam Gebrekidan" . +_:Author_SelamGebrekidan _:Article_100000009988576 . +_:Author_JoyDong "Author" . +_:Author_JoyDong "Joy Dong" . +_:Author_JoyDong _:Article_100000009988576 . +_:Author_ChangWLee "Author" . +_:Author_ChangWLee "Chang W. Lee" . +_:Author_ChangWLee _:Article_100000009988576 . +_:Author_WeiyiCai "Author" . +_:Author_WeiyiCai "Weiyi Cai" . +_:Author_WeiyiCai _:Article_100000009988576 . +_:Topic_FraudsandSwindling "Topic" . +_:Topic_FraudsandSwindling "Frauds and Swindling" . +_:Article_100000009988576 _:Topic_FraudsandSwindling . +_:Topic_MoneyLaundering "Topic" . +_:Topic_MoneyLaundering "Money Laundering" . +_:Article_100000009988576 _:Topic_MoneyLaundering . +_:Topic_BankingandFinancialInstitutions "Topic" . +_:Topic_BankingandFinancialInstitutions "Banking and Financial Institutions" . +_:Article_100000009988576 _:Topic_BankingandFinancialInstitutions . +_:Topic_RobberiesandThefts "Topic" . +_:Topic_RobberiesandThefts "Robberies and Thefts" . +_:Article_100000009988576 _:Topic_RobberiesandThefts . +_:Topic_VirtualCurrency "Topic" . +_:Topic_VirtualCurrency "Virtual Currency" . +_:Article_100000009988576 _:Topic_VirtualCurrency . +_:Topic_ComputersandtheInternet "Topic" . +_:Topic_ComputersandtheInternet "Computers and the Internet" . +_:Article_100000009988576 _:Topic_ComputersandtheInternet . +_:Topic_audioneutralimmersive "Topic" . +_:Topic_audioneutralimmersive "audio-neutral-immersive" . +_:Article_100000009988576 _:Topic_audioneutralimmersive . +_:Topic_audioneutralsuspenseful "Topic" . +_:Topic_audioneutralsuspenseful "audio-neutral-suspenseful" . +_:Article_100000009988576 _:Topic_audioneutralsuspenseful . +_:Organization_HuioneGroup "Organization" . +_:Organization_HuioneGroup "Huione Group" . +_:Article_100000009988576 _:Organization_HuioneGroup . +_:Organization_TetherOperationsLtd "Organization" . +_:Organization_TetherOperationsLtd "Tether Operations Ltd" . +_:Article_100000009988576 _:Organization_TetherOperationsLtd . +_:Organization_TelegramLLC "Organization" . +_:Organization_TelegramLLC "Telegram LLC" . +_:Article_100000009988576 _:Organization_TelegramLLC . +_:Geo_PhnomPenhCambodia "Geo" . +_:Geo_PhnomPenhCambodia "Phnom Penh (Cambodia)" . +_:Geo_PhnomPenhCambodia "{'type': 'Point', 'coordinates': [104.929, 11.549]}"^^ . +_:Article_100000009988576 _:Geo_PhnomPenhCambodia . +_:Geo_Cambodia "Geo" . +_:Geo_Cambodia "Cambodia" . +_:Geo_Cambodia "{'type': 'Point', 'coordinates': [104.9254, 11.5633]}"^^ . +_:Article_100000009988576 _:Geo_Cambodia . +_:caa44a94-9490-496b-be29-cc0e8e8ddaeb "Image" . +_:caa44a94-9490-496b-be29-cc0e8e8ddaeb "Huione is a constellation of affiliates. The headquarters of one of its companies, Huione Pay, is in Phnom Penh, Cambodia." . +_:caa44a94-9490-496b-be29-cc0e8e8ddaeb "https://static01.nyt.com/images/2025/03/10/multimedia/00int-moneylaundering-03-hpgl/00int-moneylaundering-03-hpgl-thumbStandard.jpg" . +_:caa44a94-9490-496b-be29-cc0e8e8ddaeb _:Article_100000009988576 . +_:Article_100000010036616 "Article" . +_:Article_100000010036616 "Why Dads Take Their Gay Sons to Hooters" . +_:Article_100000010036616 "Many fathers and grandfathers take their gay sons to the bar. It’s become a place of refuge — and how that happened is a curious story." . +_:Article_100000010036616 "[-0.02737586572766304, 0.09682928770780563, -0.17000800371170044, -0.041620172560214996, 0.018709277734160423, 0.051669780164957047, -0.0012781595578417182, 0.03900967910885811, -0.030436670407652855, -0.022396542131900787, -0.07485450059175491, 0.013723572716116905, 0.04392634332180023, -0.010300404392182827, -0.01133157592266798, -0.08553589135408401, -0.0008924082503654063, 0.06350750476121902, -0.002407906111329794, -0.03015195205807686, -0.09537636488676071, -0.0063226730562746525, -0.026714231818914413, -0.024014370515942574, 0.0703151598572731, -0.018952855840325356, -0.0001229372137458995, 0.02671828679740429, -0.04122105985879898, 0.05923306569457054, 0.03209163621068001, 0.047348491847515106, -0.035166822373867035, -0.00026923083350993693, -0.02681373991072178, -0.04071126505732536, -0.005176798440515995, 0.05407111346721649, -0.003821189748123288, -0.02711140364408493, 0.029732313007116318, 0.02297082543373108, -0.031266119331121445, -0.05310134217143059, 0.06096380576491356, -0.05312618985772133, 0.007158638909459114, 0.01755085587501526, 0.03520075976848602, -0.027480999007821083, 0.028144923970103264, -0.04971487820148468, -0.02800453081727028, 0.0005554311792366207, 0.05802519619464874, -0.019489290192723274, 0.03208121284842491, -0.0036584786139428616, -0.024288708344101906, 0.030626889318227768, 0.06905081123113632, 0.031564194709062576, -0.0270533449947834, 0.04223552718758583, 0.043072257190942764, 0.03137947991490364, 0.008593293838202953, 0.017510220408439636, 0.040955159813165665, -0.038426030427217484, 0.022005464881658554, 0.0020842207595705986, 0.0007732959347777069, -0.01914294809103012, -0.016648145392537117, 0.029291225597262383, 0.04100428521633148, 0.04920731857419014, -0.02305787242949009, 0.01344993244856596, 0.0724722295999527, -0.03197894245386124, 0.015734706073999405, -0.0237007737159729, -0.05123302340507507, 0.025023972615599632, 0.05385285243391991, -0.026907382532954216, 0.0067596035078167915, 0.04146578535437584, 0.048005711287260056, 0.008215697482228279, 0.022310616448521614, -0.0022001187317073345, -0.05456056818366051, 0.00606703944504261, 0.02081988751888275, 0.02542402222752571, -0.038278914988040924, -0.006032761186361313, 0.0035754444543272257, -0.05838988348841667, -0.020874755457043648, 0.025341179221868515, 0.015784475952386856, 0.020623888820409775, 0.030679477378726006, 0.05351688712835312, 0.007797476835548878, 0.06416180729866028, -0.04837801679968834, 0.045126836746931076, -0.020186835899949074, -0.07778244465589523, 0.018704386427998543, 0.007273005321621895, 0.018544256687164307, -0.02571849524974823, 0.07417857646942139, -7.164065664255759e-06, -0.008685342967510223, 0.03405114635825157, -0.04978036880493164, 0.026222199201583862, 0.04489154368638992, 0.05293944105505943, -0.05498886853456497, 0.021807707846164703, -0.02354436181485653, -0.06669323891401291, -0.010658318176865578, -0.03511672466993332, -0.012532704509794712, -0.026453876867890358, 0.062408093363046646, 0.06508149206638336, 0.043863195925951004, -0.035436127334833145, 0.001408893265761435, 0.02178247645497322, 0.03367999196052551, 0.005305805243551731, 0.013243678025901318, -0.03731878101825714, 0.05129927024245262, 0.02015761099755764, 0.04206274449825287, -0.0363851822912693, -0.06937216967344284, -0.036223478615283966, -0.008215706795454025, 0.0619557686150074, 0.006830214057117701, 0.03352707251906395, 0.007269544526934624, -0.02083573490381241, -0.007292658090591431, 0.019368726760149002, 0.07220540940761566, 0.0547250360250473, 0.05509058013558388, -0.023448726162314415, 0.026690786704421043, -0.02123316191136837, -0.05678975582122803, -0.059265799820423126, 0.01946176216006279, -0.008749742992222309, 0.005978475324809551, -0.03276696801185608, -0.04050230607390404, -0.039563555270433426, 0.028165729716420174, -0.0232184249907732, 0.03117506206035614, -0.04506363719701767, 0.0019241650588810444, -0.050093989819288254, 0.02767244726419449, -0.03651430457830429, -0.0017461669631302357, -0.07329367846250534, 0.03263568878173828, -0.020472150295972824, 0.02518593892455101, -0.0005570711800828576, 0.01341862790286541, -0.007654125802218914, -0.021592725068330765, -0.12364762276411057, -0.004247902426868677, -0.018035495653748512, -0.0286654494702816, -0.04703880101442337, -0.07490614056587219, 0.007441651541739702, 0.010920505039393902, -0.00306674069724977, 0.0018895930843427777, 0.012611876241862774, -0.047200337052345276, -0.01384781301021576, -0.03375369682908058, 0.03956323117017746, -0.014708097092807293, 0.04740351811051369, -0.005957773420959711, -0.027437975630164146, 0.0014531364431604743, 0.009173218160867691, 0.0640597715973854, -0.03935958072543144, -0.021237550303339958, -0.04292790964245796, 0.007614789064973593, 0.030556172132492065, 0.03809681534767151, 0.002948857843875885, 0.0336589589715004, 0.03940415009856224, -0.013409515842795372, 0.04891551658511162, -0.004427120555192232, 0.012456821277737617, 0.07320437580347061, 0.02008519135415554, -0.050311047583818436, -0.0032030001748353243, -0.0014783918159082532, 0.05189834535121918, -0.008325088769197464, -0.0585947260260582, 0.05814807862043381, 0.04175128415226936, -0.03389459103345871, -0.025653496384620667, -0.023014698177576065, 0.06494887173175812, 0.03853248804807663, -0.02793688327074051, -0.007241770159453154, 0.007289619650691748, -0.0181841142475605, 0.015143981203436852, -0.024249672889709473, 0.008079428225755692, 0.013738015666604042, -0.018182728439569473, 0.02660500258207321, 0.026143399998545647, 0.015843510627746582, -0.002859722124412656, -0.021556267514824867, -0.016699906438589096, -0.0067833708599209785, -0.002437414601445198, 0.0019582926761358976, -0.005009924992918968, -0.03373659774661064, -0.05873649939894676, -0.044593121856451035, -0.029472896829247475, 0.02061670459806919, -0.06748244166374207, 0.014101368375122547, -0.010861451737582684, 0.0046368734911084175, 0.00031680925167165697, 0.03478441387414932, -0.03205905109643936, -0.04162733256816864, 0.03611169382929802, 0.06700918823480606, 0.00815883930772543, 0.02045411802828312, -0.039293285459280014, -0.015622027218341827, -0.004830603022128344, -0.007852599956095219, 0.004431647248566151, -0.026025131344795227, -0.01827744022011757, -0.09126700460910797, -0.03354398533701897, 0.0017866571433842182, 0.05555334687232971, 0.033671192824840546, 0.012923075817525387, 0.017486119642853737, 0.03697206452488899, 0.0479467511177063, -0.005747227929532528, -0.05122346058487892, 0.0228168535977602, 0.060643356293439865, 0.034052371978759766, 0.008770833723247051, -0.018066707998514175, -0.025038084015250206, -0.050972357392311096, 0.037582751363515854, -0.020222380757331848, 0.016531141474843025, 0.09471947699785233, 0.014073289930820465, -0.012620273046195507, -0.0003584448422770947, -0.019661827012896538, 0.04490373656153679, 0.005538988392800093, -0.016651922836899757, -0.02047300525009632, -0.02449476532638073, 0.02193770371377468, -0.0595807284116745, 0.041018903255462646, 0.04072895646095276, 0.02357473410665989, 0.0456259548664093, -0.002176538808271289, 0.007947009056806564, -0.00715637905523181, -0.04553801193833351, -0.01594933308660984, 0.04825626686215401, -0.010001926682889462, -0.008576937019824982, 0.03277730569243431, 0.008867510594427586, -0.011446591466665268, 0.00627483893185854, 0.03796831890940666, 0.06060900539159775, -0.015076774172484875, -0.03915475308895111, 0.014686467126011848, 0.04224029555916786, 0.012148126028478146, -0.036180078983306885, 0.04956207424402237, 0.03310924768447876, -0.030824540182948112, 0.027121514081954956, -0.0312606506049633, -0.07695701718330383, 0.05644400045275688, -0.09031475335359573, 0.008418416604399681, 0.04648292809724808, -0.013713371939957142, -0.04499020054936409, 0.0062218341045081615, -0.0548907145857811, 0.023737207055091858, -0.013324335217475891, -0.035654984414577484, 0.014707373455166817, 0.01233385968953371, 0.026844054460525513, -0.02335120365023613, 0.0679907500743866, -0.00992165133357048, 0.022534826770424843, -0.012321182526648045, 0.020790942013263702, -0.0005712905549444258, 0.01716015674173832, -0.015506798401474953, -0.020263779908418655, 0.027628466486930847, -0.048213884234428406, -0.01440858468413353, 0.024326523765921593, 0.035181451588869095, 0.01829960197210312, -0.0010807595681399107, -0.10091307014226913, 0.0013000015169382095, 0.010649971663951874, -0.012803155928850174, -0.00623541884124279, 0.0030524402391165495, 0.031997520476579666, -0.0479624904692173, 0.023386532440781593, 0.038949932903051376, 0.01899596117436886, -0.01631159894168377, -0.037012483924627304, 0.0005255017313174903, -0.02796507440507412, 0.037090860307216644, -0.041118208318948746, -0.016549648717045784, -0.002138399053364992, -0.0029908691067248583, 0.04298102483153343, -0.0010648686438798904, 0.011540111154317856, 0.0693005621433258, -0.016165293753147125, -0.048850975930690765, -0.02104140631854534, -0.007363971322774887, -0.05243653059005737, 0.08469559997320175, -0.0037881575990468264, -0.0766783282160759, 0.009235277771949768, -0.02016359381377697, -0.025393923744559288, 0.027204521000385284, -0.008212247863411903, -0.05311604589223862, -0.013440079987049103, 0.07083548605442047, 0.06764935702085495, 0.06118404492735863, 0.004739923402667046, -0.0028226475697010756, 0.04075507074594498, 0.0009841595310717821, 0.01394179742783308, 0.010418115183711052, 0.0443575344979763, -0.0043410067446529865, 0.05488133057951927, 0.04761570319533348, -0.006142754107713699, -0.032771360129117966, -0.01009436510503292, 0.00020361639326438308, 0.016998646780848503, -0.06638118624687195, 0.016243087127804756, -0.01828029938042164, -0.02828191965818405, -0.04539020359516144, -0.006909821182489395, 0.05030997097492218, 0.02297705039381981, -0.029354918748140335, -0.01401875913143158, -0.01328654307872057, 0.006031442433595657, 0.02784154750406742, 0.0820874273777008, -0.017764581367373466, 0.026277679949998856, 0.014484655112028122, -0.004931333940476179, -0.016872495412826538, 0.05421936884522438, -0.017241600900888443, 0.053953226655721664, -0.028710862621665, -0.024811530485749245, 0.026970049366354942, 0.019151512533426285, 0.04370948299765587, -0.04606185853481293, -0.0050175245851278305, -0.04091022536158562, -0.052698392421007156, -0.0015146104851737618, -0.027602683752775192, 0.04426703229546547, -0.023361701518297195, 0.04206910356879234, 0.023789217695593834, -0.014457314275205135, 0.015366791747510433, -0.005997451487928629, -0.030782420188188553, -0.015110991895198822, -0.0238676518201828, 0.024765077978372574, 0.037628430873155594, 0.03356735035777092, 0.005049418658018112, 0.021585624665021896, 0.02584012970328331, 0.006426939740777016, -0.02984933741390705, -0.03174006566405296, -0.010222319513559341, 0.01894124411046505, -0.01380349975079298, 0.00879846140742302, 0.0007312619127333164, 0.0074330661445856094, 0.03250903636217117, -0.022670526057481766, 0.021748023107647896, 0.002609694143757224, -0.026880793273448944, -0.030910685658454895, 0.015425484627485275, 0.03198174387216568, 0.027450110763311386, 0.0667022094130516, 0.06225328519940376, 0.045172251760959625, -0.02593078836798668, -0.013242886401712894, 0.01722714863717556, -0.047025181353092194, -0.006430337205529213, -0.03448444977402687, 0.02143877185881138, -0.04237612709403038, -0.0075806304812431335, -0.005641911644488573, 0.02045263908803463, 0.049789343029260635, -0.06252089887857437, 0.007084944285452366, 0.03425498679280281, 0.02207193151116371, -0.009805301204323769, 0.01582730934023857, -0.021127404645085335, -0.0028000951278954744, -0.06496037542819977, -0.05082981660962105, 0.07644397020339966, -0.00894775241613388, 0.005642164032906294, 0.033381007611751556, 0.008171053603291512, -0.00634293258190155, -0.010032957419753075, -0.016504157334566116, -0.0069826762191951275, -0.0026744671631604433, -0.036740925163030624, -0.02306957356631756, 0.02995642088353634, -0.0170246884226799, 0.054385941475629807, -0.06325546652078629, -0.04924826696515083, -0.02586081251502037, -0.020160365849733353, -0.0127157773822546, 0.02627604268491268, -0.032294388860464096, -0.0068998741917312145, -0.02531103976070881, -0.001192122115753591, 0.0174278412014246, -0.06666164100170135, -0.028393849730491638, 0.03333339840173721, -0.017759643495082855, -0.004783147014677525, 0.001336350105702877, 0.0011179420398548245, -0.03380526229739189, -0.005138414911925793, 0.013565940782427788, 0.052995748817920685, 0.03208218142390251, -0.033728763461112976, 0.02502729929983616, -0.00955712329596281, 0.019603176042437553, -0.05215359106659889, -0.0079630883410573, 0.005637116264551878, -0.013899381272494793, -0.07185789197683334, -0.014747485518455505, -0.0031952611170709133, 0.0521264486014843, -0.013447451405227184, -0.019303034991025925, 0.018459735438227654, -0.02259201556444168, -0.06487542390823364, 0.02087888866662979, -0.01615038700401783, 0.024835461750626564, -0.05635447800159454, -0.06425397098064423, 0.02342054434120655, -0.06120093911886215, 0.005807111039757729, 0.05234396457672119, -0.05091038718819618, -0.005448946729302406, -0.003059975802898407, -0.019229181110858917, -0.0017923355335369706, -0.004358982667326927, -0.07148871570825577, 0.017554571852087975, -0.051859207451343536, -0.03962088003754616, -0.05782238021492958, 0.013061724603176117, -0.016979943960905075, 0.008871389552950859, -0.031443625688552856, 0.010721049271523952, -0.019056100398302078, 0.03499418869614601, -0.013891531154513359, -0.0017432714812457561, -0.03243130445480347, 0.06898123770952225, 0.0019439986208453774, -0.0566832460463047, -0.0010715716052800417, 0.01396943535655737, -0.04699184000492096, 0.08343231678009033, -0.013136052526533604, -0.00897250510752201, 0.042116064578294754, -0.07011131197214127, -0.09150230139493942, 0.008729765191674232, 0.008298053406178951, 0.029877396300435066, -0.009275317192077637, -0.06669589877128601, -0.030541421845555305, -0.01290455274283886, 0.07714316993951797, -0.03634316846728325, 0.029533054679632187, -0.08537174016237259, -0.07660948485136032, -0.006221882998943329, 0.012172413058578968, 0.0027667866088449955, -0.010950042866170406, -0.039765335619449615, 0.01913227140903473, 0.05252402275800705, -0.01957257091999054, 0.006748126354068518, 0.067057766020298, 0.039613205939531326, 0.06874256581068039, 0.020465927198529243, -0.018584299832582474, 0.05012731999158859, -0.02165297605097294, 0.02122020162642002, 0.01895328238606453, 0.02559075504541397, 0.027154546231031418, 0.023246845230460167, 0.02359033189713955, 0.03432029113173485, -0.055654074996709824, -0.05214504897594452, -0.07382120937108994, -0.010888789780437946, 0.04199296236038208, -0.0014486832078546286, 0.023010097444057465, 0.007391890045255423, 0.02220732718706131, 0.004582633264362812, -0.00926963146775961, -0.015438133850693703, -0.003055534092709422, -0.0012484337203204632, 0.01133444532752037, 0.05307599529623985, -0.01622915454208851, -0.02679809182882309, 0.011627701111137867, 0.06049644574522972, 0.04873518645763397, 0.015325881540775299, -0.021680617704987526, -0.010460822843015194, 0.04161784052848816, -0.00440569594502449, -0.023822329938411713, 0.010708626359701157, 0.009649300016462803, 0.010070543736219406, -0.053447175770998, -0.08661019057035446, -0.008657661266624928, -0.019651001319289207, -0.07673193514347076, -0.024407662451267242, 0.008311137557029724, 0.014871046878397465, -0.03502223640680313, -0.003636294510215521, 0.0232214517891407, 0.02161519229412079, 0.05408598110079765, -0.0013672326458618045, 0.0386587493121624, -0.03457057476043701, 0.01617887057363987, 0.0035463867243379354, -0.053948093205690384, 0.023696405813097954, -0.046181708574295044, 0.02027798257768154, 0.017799638211727142, 0.028929103165864944, 0.07632272690534592, -0.001292663742788136, 0.02946043573319912, 0.06067404896020889, 0.0026733390986919403, -0.040434904396533966, -0.03884672746062279, -0.008713511750102043, -0.011987132020294666, 0.07159080356359482, -0.052988167852163315, -0.00925134215503931, -0.02274101786315441, 0.032707344740629196, 0.03758402541279793, 0.05949666351079941, -0.05186138674616814, -0.02864171378314495, -0.012310110963881016, -0.016133014112710953, -0.07249660044908524, -0.028952818363904953, 0.030871430411934853, -0.006274258717894554, -0.0047253030352294445, -0.03838859125971794, -0.04067908599972725, -0.0003812877694144845, -0.02581445500254631, -0.0005682666669599712, 0.062245532870292664, 0.03801370784640312, 0.06856836378574371, 0.030121183022856712, -0.004864421207457781, 0.020624220371246338, 0.02143593691289425, 0.011730085127055645, 0.0350654311478138, 0.05612150579690933, -0.017993280664086342, 0.015782231464982033, 0.026824407279491425, -0.011247977614402771, -0.04422269016504288, -0.012456481344997883, 0.023293955251574516, 0.040831200778484344, 0.014184180647134781, 0.0669415071606636, -0.01477051991969347, -0.009675604291260242, -0.012388607487082481, -0.02292412705719471, -0.034922245889902115, -0.0332196019589901, 0.00798263493925333]" . +_:Article_100000010036616 "nyt://article/70c88a70-e850-57ce-b62b-b5ccd5c7c939" . +_:Article_100000010036616 "https://www.nytimes.com/2025/03/23/opinion/hooters-gay-family.html" . +_:Article_100000010036616 "2025-03-23"^^ . +_:Author_PeterRothpletz "Author" . +_:Author_PeterRothpletz "Peter Rothpletz" . +_:Author_PeterRothpletz _:Article_100000010036616 . +_:Topic_HomosexualityandBisexuality "Topic" . +_:Topic_HomosexualityandBisexuality "Homosexuality and Bisexuality" . +_:Article_100000010036616 _:Topic_HomosexualityandBisexuality . +_:Topic_MenandBoys "Topic" . +_:Topic_MenandBoys "Men and Boys" . +_:Article_100000010036616 _:Topic_MenandBoys . +_:Topic_Minorities "Topic" . +_:Topic_Minorities "Minorities" . +_:Article_100000010036616 _:Topic_Minorities . +_:Topic_Grandparents "Topic" . +_:Topic_Grandparents "Grandparents" . +_:Article_100000010036616 _:Topic_Grandparents . +_:Topic_BarsandNightclubs "Topic" . +_:Topic_BarsandNightclubs "Bars and Nightclubs" . +_:Article_100000010036616 _:Topic_BarsandNightclubs . +_:Topic_Discrimination "Topic" . +_:Topic_Discrimination "Discrimination" . +_:Article_100000010036616 _:Topic_Discrimination . +_:Topic_WaitersandWaitresses "Topic" . +_:Topic_WaitersandWaitresses "Waiters and Waitresses" . +_:Article_100000010036616 _:Topic_WaitersandWaitresses . +_:Topic_CustomerRelations "Topic" . +_:Topic_CustomerRelations "Customer Relations" . +_:Article_100000010036616 _:Topic_CustomerRelations . +_:Topic_Restaurants "Topic" . +_:Topic_Restaurants "Restaurants" . +_:Article_100000010036616 _:Topic_Restaurants . +_:Organization_Hooters "Organization" . +_:Organization_Hooters "Hooters" . +_:Article_100000010036616 _:Organization_Hooters . +_:0769f696-2e07-4fa9-9ee7-9992ec28ecb7 "Image" . +_:0769f696-2e07-4fa9-9ee7-9992ec28ecb7 "" . +_:0769f696-2e07-4fa9-9ee7-9992ec28ecb7 "https://static01.nyt.com/images/2025/03/23/opinion/23rothpletz-image/23rothpletz-image-thumbStandard.jpg" . +_:0769f696-2e07-4fa9-9ee7-9992ec28ecb7 _:Article_100000010036616 . +_:Article_100000010065487 "Article" . +_:Article_100000010065487 "Keir Starmer on Putin, Trump and Europe’s Challenge: ‘We’ve Known This Moment Was Coming’" . +_:Article_100000010065487 "The British prime minister said in a series of conversations that the tectonic shifts in America’s relationship with Europe and Russia had to be a ‘galvanizing moment.’" . +_:Article_100000010065487 "[0.03844505548477173, 0.07636579126119614, -0.17925383150577545, -0.060283005237579346, 0.09450335800647736, 0.08512014150619507, -0.04725240543484688, -0.011987130157649517, 0.10811272263526917, 0.004162799101322889, -0.046916455030441284, 0.005835940595716238, 0.026204774156212807, 0.04270274192094803, 0.07855269312858582, -0.011884406208992004, 7.772394747007638e-05, -0.008268059231340885, -0.0261436328291893, 0.07816407829523087, -0.04919285327196121, -0.02885843627154827, -0.03130157291889191, -0.0011279013706371188, 0.031473539769649506, 0.04811226949095726, -0.009682913310825825, -0.01267898827791214, -0.00627406919375062, 0.005060948897153139, 0.054132331162691116, -0.0702853575348854, -0.04827414080500603, 0.025325147435069084, -0.056018341332674026, -0.08378830552101135, 0.010787742212414742, 0.013430659659206867, 0.0005711800185963511, -0.0456726960837841, 0.03540033847093582, -0.01763269118964672, 0.028341809287667274, -0.01965281367301941, 0.11271078884601593, -0.039632681757211685, -0.0273272767663002, 0.003641213057562709, 0.002082579769194126, 0.012734624557197094, 0.041685592383146286, -0.009500558488070965, 0.03355114907026291, -0.046966101974248886, 0.015633475035429, 0.04660460725426674, 0.05902770161628723, 0.036763787269592285, 0.0814933031797409, -0.004248685669153929, 0.042516786605119705, -0.020677320659160614, 0.017574327066540718, 0.0372711718082428, -0.02985551580786705, 0.02087385766208172, -0.05018632486462593, 0.016617167741060257, -0.020081115886569023, -0.03470107540488243, 0.02153831347823143, -0.06690581142902374, 0.022005030885338783, 0.0016621252289041877, -0.07232467830181122, 0.0054436735808849335, -0.027521144598722458, 0.002254914492368698, 0.010470515117049217, -0.011386080645024776, -0.006606141105294228, -0.026771357282996178, 0.053344693034887314, -0.038877878338098526, 0.03931937366724014, 0.009955876506865025, 0.00764126842841506, -0.015620646066963673, -0.014465299434959888, 0.0711364820599556, 0.0009931311942636967, 0.006040097679942846, -0.010705693624913692, 0.010083582252264023, -0.04680498316884041, 0.014012373052537441, -0.027410490438342094, 0.0030457156244665384, -0.032024335116147995, -0.037473756819963455, -0.06954562664031982, -0.009597033262252808, -0.0305315013974905, -0.012795956805348396, 0.03783068433403969, 0.009434417821466923, -0.021220626309514046, -0.06509071588516235, 0.06025920808315277, -0.014632700011134148, -0.04085731506347656, 0.02596389688551426, -0.003016263712197542, -0.004701754543930292, 0.0005250522517599165, -0.021902550011873245, 0.03496294096112251, -0.06881450861692429, 0.02476133592426777, 0.023423224687576294, -0.009489755146205425, -0.03722422569990158, -0.048537783324718475, 0.05984664335846901, 0.009813516400754452, 0.006711984518915415, -0.027787989005446434, 0.015120003372430801, 0.03172286972403526, -0.01398511789739132, -0.01396133191883564, -0.05187802389264107, 0.029849527403712273, 0.031674645841121674, 0.024630878120660782, 0.0716065838932991, 0.02379501610994339, -0.050658416002988815, 0.06353044509887695, 0.017230071127414703, 0.02118416130542755, -0.027807505801320076, -0.02102433517575264, -0.030831564217805862, 0.018789220601320267, -0.008016354404389858, 0.004372604191303253, -0.026428809389472008, -0.027510831132531166, 0.025779062882065773, -0.007645316421985626, 0.009753151796758175, 0.01130822952836752, 0.03967949002981186, 0.017944451421499252, -0.017476540058851242, -0.04556265473365784, -0.035325102508068085, -0.007415683474391699, 0.013441420160233974, -0.010374687612056732, -0.02972010336816311, -0.03536253049969673, 0.00621851347386837, 0.07166119664907455, -0.018657894805073738, 0.06119949743151665, -0.008114966563880444, 0.0196980033069849, 0.008937261998653412, -0.02509445697069168, -0.03382634371519089, 0.00555207347497344, -0.025611257180571556, 0.0491844117641449, -0.005990438163280487, 0.05216972902417183, -0.06475377082824707, 0.01543730404227972, -0.02704549953341484, -0.02561771497130394, -0.009284179657697678, 0.007990751415491104, -0.00729716382920742, 0.01707316003739834, 0.01726623624563217, 0.009641592390835285, -0.017518162727355957, -0.050316598266363144, -0.00760229816660285, -0.06870924681425095, -0.045620426535606384, -0.07663740962743759, -0.044050924479961395, 0.002831107471138239, -0.032212331891059875, 0.06065453588962555, -0.0028429394587874413, 0.02015155367553234, -0.03274241089820862, -0.03218305483460426, -0.006381430197507143, -0.003796267556026578, -0.018376315012574196, -0.03040182590484619, 0.07123393565416336, -0.004804182332009077, 0.06684370338916779, -0.04882102832198143, -0.008503529243171215, 0.11305341869592667, 0.003574226051568985, -0.06112193688750267, -0.017669592052698135, -0.04167180508375168, -0.009087015874683857, 0.030903460457921028, 0.0015554066048935056, -0.011840010061860085, 0.057711441069841385, 0.014446022920310497, 0.028125913813710213, -0.014918865635991096, 0.031306054443120956, 0.02444293722510338, -0.013466287404298782, -0.0066071767359972, -0.0489385649561882, -0.06647160649299622, -0.025786276906728745, -0.02981436811387539, -0.011536644771695137, 0.06672244518995285, 0.07018033415079117, -1.5979880117811263e-05, 0.0723831057548523, -0.004187389742583036, -0.0055135032162070274, -0.05096058174967766, 0.022205445915460587, 0.0001836482115322724, 0.0237989891320467, -0.032946277409791946, -0.0272342711687088, -0.06393428891897202, 0.014144998043775558, 0.06454072147607803, 0.0002518698456697166, 0.02413320727646351, 0.010736757889389992, 0.01889920048415661, -0.03518029302358627, 0.0016439720056951046, 0.008247029036283493, 0.06331068277359009, -0.03204202279448509, 0.007197816856205463, 0.08424293994903564, -0.021299416199326515, 0.014603376388549805, 0.0285047460347414, -0.07624081522226334, 0.028387749567627907, -0.05089748278260231, -0.04387236386537552, -0.03574574738740921, -0.054782379418611526, -0.0037911906838417053, -0.0007944093667902052, -0.029455212876200676, 0.018193209543824196, 0.03379131108522415, 0.013649944216012955, 0.05300067365169525, -0.06005827710032463, -0.06914233416318893, 0.05010276287794113, -0.04695774242281914, 0.008281688205897808, 0.0369732566177845, -0.077333964407444, -0.0019991062581539154, 0.005980496760457754, -0.04044845700263977, 0.0343758761882782, 0.05280398204922676, 0.03261026740074158, 0.06792117655277252, 0.008703355677425861, -0.003155668033286929, -0.02623511105775833, 0.011025219224393368, 0.023732738569378853, 0.005566105246543884, -0.0026655991096049547, 0.012657584622502327, 0.11563650518655777, -0.04279307276010513, -0.020531674847006798, -0.018739311024546623, 0.04747040197253227, 0.019236646592617035, 0.02522328309714794, 0.051702164113521576, -0.015338333323597908, -0.013617332093417645, 0.0005034189671278, -0.04423445835709572, 0.00564187066629529, 0.004602217581123114, -0.07088879495859146, 0.017224745824933052, 0.0028656329959630966, 0.03375406190752983, -0.05940311774611473, 0.039947569370269775, 0.04877891764044762, 0.04039129242300987, 0.07032524794340134, 0.02921372652053833, -0.040166426450014114, -0.044374097138643265, 0.004533571656793356, -0.05290539935231209, 0.002224802738055587, 0.048265211284160614, 0.02192424051463604, 0.02788914181292057, -0.04388808831572533, 0.03186579421162605, -0.026981906965374947, -0.02378624863922596, 0.025926606729626656, -0.01011835876852274, -0.0865836814045906, 0.015703842043876648, 0.03237288072705269, 0.0435318686068058, -0.001058355439454317, 0.054630156606435776, 0.06908876448869705, -0.035887520760297775, -0.003821965539827943, -0.014712457545101643, 0.02374921180307865, 0.056681156158447266, -0.04571259021759033, -0.006173490080982447, 0.034006938338279724, 0.014482498168945312, -0.050568122416734695, 0.033833641558885574, -0.026705151423811913, 0.011991054750978947, 0.0310763418674469, -0.04499752074480057, 0.015618817880749702, 0.028986413031816483, -0.03798085078597069, 0.0029996493831276894, 0.024745160713791847, -0.06326974928379059, 0.0032765581272542477, -0.053207170218229294, -0.007604439277201891, 0.043364930897951126, -0.010747242718935013, 0.008723834529519081, 0.020853746682405472, -0.010677095502614975, -0.033470723778009415, -0.01244442630559206, -0.03436557576060295, 0.060874540358781815, -0.0006514934357255697, -0.014557842165231705, -0.04280085116624832, -0.053018420934677124, -0.025878766551613808, 0.009244904853403568, -0.021297641098499298, -0.005134535953402519, -0.021578889340162277, 0.062442392110824585, 0.023600362241268158, -0.036776237189769745, 0.02443988248705864, -0.026911212131381035, 0.025626663118600845, 0.023873068392276764, 0.008560086600482464, -0.007205820642411709, -0.00672499556094408, 0.021309154108166695, 0.04195505008101463, -0.032293159514665604, 0.011010829359292984, -0.002304373774677515, -0.005056323017925024, 0.0193804744631052, -0.021752895787358284, -0.049106284976005554, 0.01711018942296505, -0.04399949312210083, -0.022982409223914146, -0.03620028868317604, -0.01840887777507305, -0.017193960025906563, 0.005912794265896082, -0.035019148141145706, 0.02515900880098343, 0.07394913583993912, -0.002435187343508005, -0.03354061394929886, -0.012639433145523071, 0.049173127859830856, 0.02578299678862095, -0.007110254373401403, 0.00105610815808177, 0.022694462910294533, 0.021862376481294632, 0.034030791372060776, -0.03858620673418045, -0.005369647406041622, -0.006969386711716652, 0.06811132282018661, 0.01059641968458891, 0.002102574100717902, -0.010851910337805748, -0.010260705836117268, 0.014888975769281387, 0.002270362339913845, 0.016220251098275185, 0.04257821664214134, 0.005559847224503756, -0.013570710085332394, -0.030071182176470757, -0.03467671200633049, 0.006316699553281069, 0.03961784020066261, 0.03821852058172226, -0.05957864224910736, -0.03049008548259735, 0.0052987756207585335, 0.04283441603183746, 0.08791369199752808, 0.006392827257514, -0.013444813899695873, 0.004481463693082333, -0.010499962605535984, -0.020620742812752724, -0.022257767617702484, 0.040660109370946884, 0.01686207763850689, 0.11074643582105637, -0.06640872359275818, -0.00680095748975873, 0.01756729744374752, -0.018144994974136353, 0.028141235932707787, 0.032694075256586075, -0.006639935541898012, -0.03068622760474682, 0.00024925588513724506, 0.00021193758584558964, -0.03204856440424919, -0.01697721891105175, 0.01240029651671648, -0.003894924186170101, 0.008309927769005299, -0.019274862483143806, -0.019809255376458168, 0.01395460031926632, 0.013894527219235897, -0.024968452751636505, 0.016831757500767708, 0.003105226904153824, -0.014886352233588696, 0.035570178180933, 0.009673748165369034, 0.0024378846865147352, 0.014410915784537792, -0.0022296567913144827, -0.08784309029579163, 0.0074518355540931225, 0.04522135481238365, -0.029826875776052475, -0.03690754622220993, 0.01711484044790268, 0.012354161590337753, 0.0667693167924881, 0.003041821299120784, 0.03714225813746452, -0.039728716015815735, -0.0396820493042469, -0.012040255591273308, -0.0012564343633130193, 0.018843509256839752, 0.044799499213695526, 0.029582802206277847, 0.09428920596837997, 0.03767962381243706, -0.011117959395051003, 0.025662321597337723, -0.0029158296529203653, 0.0005014927010051906, 0.011330598033964634, -0.021604010835289955, -0.04815908148884773, 0.01191396452486515, -0.04546401649713516, -0.04145873710513115, 0.007963928394019604, 0.06885731220245361, 0.040511179715394974, -0.03690606355667114, -0.015934986993670464, 0.0006664845859631896, -0.037017207592725754, 0.022528499364852905, -0.004990845452994108, -0.05660581588745117, 0.023175794631242752, -0.051782526075839996, -0.056747086346149445, 0.06448924541473389, 0.02243473008275032, -0.017955634742975235, 0.013501548208296299, 0.028990983963012695, 0.01853189431130886, -0.0028339403215795755, -0.00631056958809495, -0.04126209020614624, 0.046551045030355453, -0.02064168080687523, -0.0354556106030941, 0.053068045526742935, 0.04046434164047241, 0.015235121361911297, 0.003318477887660265, 0.0005460634711198509, -0.0016277018003165722, -0.011648030951619148, -0.0022452932316809893, 0.03945936635136604, -0.013634431175887585, 0.013722969219088554, 0.0006385622546076775, -0.010562781244516373, 0.04051802679896355, -0.0710841491818428, 0.003945403732359409, -0.026527797803282738, 0.025707678869366646, -0.021358158439397812, -0.009077277034521103, -0.026929372921586037, -0.046378374099731445, -0.03179164603352547, 0.01971176639199257, -0.02798602357506752, 0.020892400294542313, 0.024473782628774643, -0.006844505667686462, 0.0166937243193388, -0.01816467195749283, 0.00889201182872057, -0.01799253188073635, 0.016493795439600945, 0.04776512458920479, -0.05545559898018837, -0.05501720309257507, -0.029948780313134193, -0.015412638895213604, -0.006748106796294451, -0.019058287143707275, 0.0036566832568496466, -0.0813547819852829, -0.017000041902065277, 0.015154518187046051, -0.057305313646793365, 0.0016426638467237353, 0.02681197039783001, -0.009343845769762993, 0.031025966629385948, -0.004014235455542803, -0.029225056990981102, 0.052242688834667206, -0.027783531695604324, 0.026111846789717674, -0.04416773095726967, -0.05179757997393608, -0.01558862067759037, -0.009159073233604431, 0.010884135961532593, -0.0630108192563057, -0.06707966327667236, -0.002454071771353483, 0.046298447996377945, 0.009236582554876804, 0.004048740025609732, 0.046672552824020386, -0.07376106828451157, -0.0039981999434530735, 0.01875123381614685, 0.041057292371988297, 0.02278219722211361, 0.0005818579229526222, 0.01927734725177288, 0.026047522202134132, 0.01287982240319252, -0.006448837928473949, -0.033341675996780396, 0.05408574640750885, 0.007422362919896841, 0.03579138219356537, -0.013823754154145718, -0.015462840907275677, -0.004588888492435217, -0.02745620720088482, -0.003904548939317465, -0.008950981311500072, -0.008824992924928665, 0.01119084469974041, 0.0213044174015522, -0.029826689511537552, -0.05468156933784485, -0.0025630949530750513, -0.003693606471642852, -0.04142187535762787, 0.03546494245529175, -0.06615901738405228, 0.04183974862098694, 0.03489655256271362, 0.016117125749588013, -0.0007733888342045248, -0.02511170506477356, -0.021818062290549278, 0.030588136985898018, 0.044128820300102234, -0.05835040658712387, -0.051896508783102036, 0.030797405168414116, -0.001549591077491641, -0.021855901926755905, -0.001680175308138132, 0.03934840112924576, 0.010804743506014347, 0.02078784815967083, 0.058408547192811966, 0.06778799742460251, 0.023949241265654564, 0.023814810439944267, 0.00607413612306118, -0.006246115081012249, 0.05676629766821861, -0.03645598888397217, 0.02217518538236618, 0.019346468150615692, 0.010305976495146751, 0.02182236686348915, -0.009824773296713829, -0.025553809478878975, -0.008461790159344673, 0.001635315828025341, 0.002692233771085739, -0.016894454136490822, -0.07222532480955124, -0.009191240184009075, -0.021173566579818726, -0.03552364930510521, -0.0195603184401989, 0.023747270926833153, -0.003987190779298544, 0.027919135987758636, 0.02770477719604969, 0.020746024325489998, 0.005641847383230925, 0.02115393429994583, 0.041486650705337524, -0.025568244978785515, 0.01617237739264965, -0.001985474256798625, -0.030577003955841064, -0.025666330009698868, 0.06116992235183716, 0.025920743122696877, -0.03193805366754532, -0.008035615086555481, 0.0018799984827637672, -0.03529380261898041, 0.06375309824943542, 0.0007972555467858911, 0.02548309974372387, -0.0005509566399268806, 0.010322043672204018, 0.012015985324978828, -0.010935385711491108, -0.023388825356960297, -0.028276488184928894, 0.041755933314561844, 0.004086868371814489, 0.03076338768005371, -0.04710046201944351, 0.019702795892953873, 0.05090884491801262, -0.04707377031445503, 0.027188709005713463, 0.033957310020923615, 0.010294615291059017, 0.01578410156071186, 0.024927731603384018, 0.0650545060634613, 0.07228132337331772, -0.013194338418543339, -0.015146752819418907, -0.06397505849599838, 0.009297121316194534, 0.044093724340200424, 0.017672190442681313, -0.0247164499014616, -0.06204550713300705, -0.034918759018182755, -0.03917444497346878, 0.023330578580498695, 0.03727742284536362, -0.07037705928087234, 0.022179745137691498, 0.005495485384017229, 0.04612633213400841, -0.02776387333869934, -0.0175042524933815, 0.016993792727589607, -0.026262084022164345, 0.0024328429717570543, -0.021243736147880554, 0.0342995747923851, -0.037287525832653046, -0.04175475984811783, -0.05783717706799507, -0.04104525223374367, 0.04808841273188591, 0.053918130695819855, -0.02307380735874176, 0.020321911200881004, 0.009267926216125488, 0.08746442943811417, 0.011410574428737164, 0.01066052820533514, -0.07266289740800858, -0.023231476545333862, -0.05683467537164688, -0.02124651148915291, -0.036801863461732864, 0.018860360607504845, -0.0360787995159626, 0.04180237650871277, 0.05456117168068886, -0.02182484045624733, 0.005693103186786175, -0.015506044961512089, 0.01792100816965103, -0.026798833161592484, -0.03371133282780647, -0.02671392634510994, -0.0377604216337204, 0.019002269953489304]" . + } +} +``` + +{/* */} + + + +![import sample data](/images/agents/30-days-of-agents/day-21-hypermode-4.png) + + + + + +## Verify your graph + +Run the following query in Ratel to verify your graph data is loaded: + +```dql +{ + articles(func:type(Article),first:100) { + Article.title + Article.uri + Article.url + Article.published + Article.abstract + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + Article.geo { + Geo.name + } + } +} +``` + +![querying the graph using Ratel](/images/agents/30-days-of-agents/day-21-ratel-query.png) + +## What you've accomplished + +In 25 minutes, you've mastered advanced graph data modeling: + +**Dgraph architecture**: understood distributed graph databases and modern +capabilities + +**Real-world data modeling**: worked with complex news article knowledge graphs + +**Multi-type graphs**: explored lexical, domain, visual, and geospatial graph +patterns + +**Advanced patterns**: learned temporal modeling, multi-modal integration, and +provenance tracking + +**Agent integration**: connected sophisticated graph capabilities to your agents + +## Next steps + +In the next + + + Master DQL (Dgraph Query Language) for complex graph queries and integrate + Dgraph with your agents using multiple client libraries. + + +## Pro tip for today + +Experiment with different graph modeling approaches: + +```text +Help me understand when to use different knowledge graph types: + +1. For a customer support system: What type of knowledge graph would be most effective? +2. For a research assistant: How would you model academic papers and citations? +3. For a business intelligence system: What relationships matter most for competitive analysis? +4. For a content recommendation system: How do you balance multiple types of similarity? + +Show me schema examples and explain the reasoning behind each design choice. +``` + +This develops intuition for choosing the right graph modeling approach for +different use cases. + +--- + +**Time to complete**: ~25 minutes + +- **Skills learned** Dgraph architecture, RDF data modeling, multi-type + knowledge graphs, temporal and provenance patterns, agent integration + strategies + +**Next**: day 22 - DQL querying and multi-language client integration + + + **Remember** Advanced graph modeling is about representing not just what you + know, but how you know it, when you knew it, and how confident you are about + it. This metadata becomes crucial for agent reasoning. + diff --git a/agents/30-days-of-agents/day-22.mdx b/agents/30-days-of-agents/day-22.mdx new file mode 100644 index 00000000..2c5ced3d --- /dev/null +++ b/agents/30-days-of-agents/day-22.mdx @@ -0,0 +1,2105 @@ +--- +title: "Day 22: Dgraph - Querying Knowledge Graphs with DQL" +sidebarTitle: "Day 22: Dgraph Querying" +description: + "Master DQL (Dgraph Query Language) for complex graph queries, explore the + news knowledge graph with Ratel, and integrate Dgraph with agents using + Python, JavaScript, and Go clients." +--- + + + **Goal**: master DQL querying and multi-language client integration with Dgraph + +**Theme**: context engineering week - advanced graph query mastery + +**Time investment**: ~30 minutes + + + +Welcome to Day 22! Yesterday you built sophisticated knowledge graphs with +Dgraph. Today you'll master **DQL (Dgraph Query Language)** for complex graph +queries and learn to integrate Dgraph with your agents using multiple +programming languages. + +DQL enables sophisticated graph traversal and analysis that powers intelligent +agent reasoning. + +## What you'll accomplish today + +- Master DQL syntax for complex graph queries +- Use Ratel (Dgraph's UI) to explore the news knowledge graph +- Learn multi-hop graph traversal and aggregation techniques +- Integrate Dgraph with agents using Python, JavaScript, and Go clients +- Build sophisticated graph-powered agent workflows + + + This requires access to a Dgraph instance (free Cloud instance available) and + familiarity with basic programming concepts. Be sure to complete Day 21 first. + You'll work with multiple client libraries. + + +## Step 1: DQL fundamentals + +DQL (Dgraph Query Language) is designed specifically for graph traversal and +analysis: + +### Basic DQL syntax + +```dql +{ + articles(func: type(Article)) { + Article.title + Article.abstract + Article.uri + } +} +``` + +### Key DQL concepts + +- **Functions**: Entry points for queries (`type()`, `eq()`, `allofterms()`, + etc.) +- **Predicates**: Properties to retrieve or traverse +- **Variables**: Store intermediate results (`var(func: ...)`) +- **Filters**: Refine results at any level(`@filter()`) +- **Aggregations**: Calculate values across sets (`count`, `sum`, `avg`) + +### DQL vs. other query languages + +**DQL advantages**: + +- Native graph traversal with unlimited depth +- Variables for complex multi-stage queries +- Built-in aggregation and filtering at any level +- Optimized for distributed graph operations + + + **DQL thinking** Unlike SQL joins, DQL follows relationships naturally. Think + about traversing paths through connected data rather than combining tables. + + +## Step 2: Exploring with Ratel + +Ratel is Dgraph's built-in UI for query development and visualization. We'll use +Ratel to execute queries and explore the results. Follow the steps described in +Day 21 to connect Ratel to your Hypermode Graph. + +### Filtering and ordering + +You can filter results using the `@filter` directive: + +```graphql +{ + articles(func: type(Article)) @filter(has(Article.abstract)) { + Article.title + Article.abstract + } +} +``` + +This returns only articles that have an abstract. + +To order results, use the `orderasc` or `orderdesc` parameter: + +```graphql +{ + articles(func: type(Article), orderasc: Article.title) { + Article.title + Article.abstract + } +} +``` + +**Schema Improvement:** Add an `@index` to `Article.title` to enable fast +sorting: + +```dql +: string @index(exact) . +``` + +### Date filtering + +Your schema includes `Article.published` as a date field. To filter by date: + +```graphql +{ + recent_articles(func: type(Article)) @filter(ge(Article.published, "2025-01-01T00:00:00Z")) { + Article.title + Article.published + } +} +``` + +**Schema Improvement** Add a `datetime` index for faster date-based queries: + +```dql +: datetime @index(hour) . +``` + +### Nested traversals + +Follow relationships between entities with nested queries: + +```graphql +{ + topics(func: type(Topic)) { + Topic.name + ~Article.topic { # Traverse reverse edge to articles + Article.title + Article.abstract + } + } +} +``` + +You can also query articles and include their related entities: + +```graphql +{ + articles(func: type(Article)) { + Article.title + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } +} +``` + +### Full-text search + +The schema has a full-text index on `Topic.name`, enabling text search: + +```graphql +{ + topics(func: anyoftext(Topic.name, "technology AI")) { + Topic.name + ~Article.topic { + Article.title + } + } +} +``` + +**Schema Improvement** Add full-text search to Article titles and abstracts: + +```dql +: string @index(fulltext) . +: string @index(fulltext, term) . +``` + +### Geospatial queries + +Your schema has `Geo.location` as a `geo` field, enabling location-based +queries: + +```graphql +{ + nearby_locations(func: near(Geo.location, [-74.0060, 40.7128], 50000)) { + Geo.name + Geo.location + ~Article.geo { + Article.title + } + } +} +``` + +This finds locations within 10km of New York City coordinates and their +associated articles. + +### Vector similarity search + +The schema includes `Article.embedding` with an HNSW vector index, allowing +semantic searches: + +```graphql +query vector_search($embedding: string, $limit: int) { + articles(func: similar_to(Article.embedding, $limit, $embedding)) { + uid + Article.title + Article.abstract + score + } + } +``` + +This finds the 5 articles with embeddings most similar to the given vector. + +### Advanced queries: Combining multiple filters + +Combine multiple filters for complex queries: + +```graphql +{ + tech_articles_2025(func: type(Article)) @filter( + anyoftext(Article.abstract, "technology AI") AND + ge(Article.published, "2025-01-01") AND + has(Article.geo) + ) { + Article.title + Article.abstract + Article.published + Article.geo { + Geo.name + Geo.location + } + Article.topic { + Topic.name + } + } +} +``` + +### Additional schema improvements + +To enable more advanced queries, consider these improvements: + +1. Add indexes to organization and author names for searching: + + ```dql + : string @index(exact, term) . + : string @index(exact, term) . + ``` + +2. Add count indexing to quickly count relationships: + + ```dql + : [uid] @count @reverse . + : [uid] @count @reverse . + ``` + +3. Add unique ID constraints for article URIs: + + ```dql + : string @index(exact) @upsert . + ``` + +4. Add date partitioning for more efficient date range queries: + + ```dql + : datetime @index(year, month, day, hour) . + ``` + +These enhancements will provide more query capabilities without requiring +changes to your data model. + +### Client directives + +DQL offers several client-side directives that modify query behavior without +affecting the underlying data. + +#### The `@cascade` directive + +The `@cascade` directive filters out nodes where any of the requested fields are +null or empty: + +```graphql +{ + articles(func: type(Article)) @cascade { + Article.title + Article.abstract + Article.topic { + Topic.name + } + } +} +``` + +This returns only articles that have all three fields: title, abstract, and at +least one topic. + +#### The `@facets` directive + +While not currently configured in your schema, facets let you add metadata to +edges. To add and query facets, you'd update your schema like this: + +```dql +: [uid] @reverse @facets(relevance: float) . +``` + +Then query with: + +```graphql +{ + articles(func: type(Article)) { + Article.title + Article.topic @facets(relevance) { + Topic.name + } + } +} +``` + +#### The `@filter` directive (with multiple conditions) + +Combine multiple filter conditions using logical operators: + +```graphql +{ + articles(func: type(Article)) @filter(has(Article.abstract) AND (anyoftext(Article.abstract, "climate") OR anyoftext(Article.abstract, "weather"))) { + Article.title + Article.abstract + } +} +``` + +#### The `@recurse` directive + +For recursive traversals (useful if your graph has hierarchical relationships): + +```graphql +{ + topics(func: type(Topic)) { + Topic.name + subtopics @recurse(depth: 3) { + name + subtopics + } + } +} +``` + +**Note** This would require adding a self-referential `subtopics` predicate to +your schema. + +### Aggregation queries + +DQL provides functions for aggregating data: + +#### Basic count + +```graphql +{ + total_articles(func: type(Article)) { + count(uid) + } +} +``` + +#### Count with grouping + +```graphql +{ + topics(func: type(Topic)) { + Topic.name + article_count: count(~Article.topic) + } +} +``` + +This counts how many articles are associated with each topic. + +#### Multiple aggregations + +```graphql +{ + articles(func: type(Article)) { + // trunk-ignore(vale/error) + topic_stats: Article.topic { + # Requires @index(exact) on Topic.name + topic_min: min(Topic.name) + topic_max: max(Topic.name) + topic_count: count(uid) + } + } +} +``` + +{/* */} + +#### Value-based aggregations + +For numeric fields with appropriate indexes (not in your current schema): + +```graphql +{ + # This would require adding a numeric wordCount field with an @index(int) + article_stats(func: type(Article)) { + min_words: min(Article.wordCount) + max_words: max(Article.wordCount) + avg_words: avg(Article.wordCount) + sum_words: sum(Article.wordCount) + } +} +``` + +#### Grouping with `@groupby` + +Group and aggregate data (requires adding `@index` directives to the fields used +in `@groupby`): + +```graphql +{ + articles(func: type(Article)) @groupby(Article.published) { + month: min(Article.published) + count: count(uid) + } +} +``` + +**Note** This would require `: datetime @index(month)` in the +schema. + +#### Date-based aggregations + +```graphql +{ + publications_by_month(func: type(Article)) { + count: count(uid) + month: datetrunc(Article.published, "month") + } @groupby(month) +} +``` + +**Note** This requires the proper `datetime` index on Article.published. + +### Combined advanced example + +This example combines multiple directives and aggregations: + +```graphql +{ + topic_statistics(func: type(Topic)) @filter(has(~Article.topic)) { + Topic.name + articles: ~Article.topic @cascade { + count: count(uid) + recent_count: count(uid) @filter(ge(Article.published, "2025-01-01T00:00:00Z")) + oldest: min(Article.published) + newest: max(Article.published) + } + } +} +``` + +This returns each topic with article statistics, including total count, recent +count, and publication date ranges. + +## Step 4: Client integrations + +Dgraph provides clients for multiple programming languages, including Python, +Go, and JavaScript. You can use these clients to connect to your Dgraph instance +and perform operations like queries, mutations, and transactions. + +### Setup and basic connection + + + + +```python +import pydgraph +import grpc +import json +from datetime import datetime + +# Create Dgraph client +def create_client(): + stub = pydgraph.DgraphClientStub('localhost:9080') + client =pydgraph.open("dgraph://") + return client + +# Example agent integration class +class NewsGraphAgent: + def __init__(self): + self.client = create_client() + + def search_articles_by_topic(self, topic_name, limit=10): + """Search articles using full-text search on topic names""" + query = f""" + {{ + topics(func: anyoftext(Topic.name, "{topic_name}")) {{ + Topic.name + articles: ~Article.topic (first: {limit}) {{ + uid + Article.title + Article.abstract + Article.published + Article.uri + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def search_articles_by_content(self, search_terms, limit=10): + """Full-text search across article titles and abstracts""" + query = f""" + {{ + articles(func: anyoftext(Article.title, "{search_terms}"), first: {limit}) {{ + uid + Article.title + Article.abstract + Article.published + Article.topic {{ + Topic.name + }} + Article.org {{ + Organization.name + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def get_recent_articles(self, days_back=30, limit=20): + """Get articles published within the last N days""" + from datetime import datetime, timedelta + cutoff_date = (datetime.now() - timedelta(days=days_back)).isoformat() + "Z" + + query = f""" + {{ + recent_articles(func: type(Article)) @filter(ge(Article.published, "{cutoff_date}")) + (orderdesc: Article.published, first: {limit}) {{ + uid + Article.title + Article.abstract + Article.published + Article.topic {{ + Topic.name + }} + Article.org {{ + Organization.name + }} + Article.geo {{ + Geo.name + Geo.location + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def search_articles_near_location(self, latitude, longitude, radius_meters=50000, limit=10): + """Find articles associated with locations near given coordinates""" + query = f""" + {{ + nearby_locations(func: near(Geo.location, [{longitude}, {latitude}], {radius_meters})) {{ + Geo.name + Geo.location + articles: ~Article.geo (first: {limit}) {{ + uid + Article.title + Article.abstract + Article.published + Article.topic {{ + Topic.name + }} + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def vector_similarity_search(self, embedding_vector, limit=5): + """Perform semantic search using article embeddings""" + query = """ + query vector_search($embedding: string, $limit: int) { + articles(func: similar_to(Article.embedding, $limit, $embedding)) { + uid + Article.title + Article.abstract + Article.published + score + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } + } + """ + + variables = { + "$embedding": json.dumps(embedding_vector), + "$limit": str(limit) + } + + txn = self.client.txn() + try: + response = txn.query(query, variables=variables) + return json.loads(response.json) + finally: + txn.discard() + + def get_topic_statistics(self): + """Get comprehensive statistics for each topic""" + query = """ + { + topic_statistics(func: type(Topic)) @filter(has(~Article.topic)) { + Topic.name + total_articles: count(~Article.topic) + recent_articles: count(~Article.topic @filter(ge(Article.published, "2025-01-01T00:00:00Z"))) + oldest_article: min(val(~Article.topic)) { + Article.published + } + newest_article: max(val(~Article.topic)) { + Article.published + } + } + } + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def complex_filtered_search(self, content_terms, topic_terms=None, since_date="2025-01-01", has_location=False): + """Advanced search combining multiple filters and conditions""" + location_filter = "AND has(Article.geo)" if has_location else "" + topic_filter = f'AND anyoftext(Article.topic, "{topic_terms}")' if topic_terms else "" + + query = f""" + {{ + filtered_articles(func: type(Article)) @filter( + anyoftext(Article.abstract, "{content_terms}") AND + ge(Article.published, "{since_date}T00:00:00Z") + {topic_filter} + {location_filter} + ) @cascade {{ + uid + Article.title + Article.abstract + Article.published + Article.topic {{ + Topic.name + }} + Article.geo {{ + Geo.name + Geo.location + }} + Article.org {{ + Organization.name + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def analyze_publication_trends(self): + """Analyze publication patterns over time using groupby""" + query = """ + { + publication_trends(func: type(Article)) @groupby(Article.published) { + month: datetrunc(Article.published, "month") + article_count: count(uid) + } + } + """ + + txn = self.client.txn() + try: + response = txn.query(query) + data = json.loads(response.json) + return self._process_publication_trends(data) + finally: + txn.discard() + + def get_normalized_article_data(self, limit=10): + """Get flattened article data using @normalize""" + query = f""" + {{ + articles(func: type(Article), first: {limit}) @normalize {{ + title: Article.title + abstract: Article.abstract + published: Article.published + uri: Article.uri + topics: Article.topic {{ + name: Topic.name + }} + organizations: Article.org {{ + name: Organization.name + }} + location: Article.geo {{ + name: Geo.name + }} + }} + }} + """ + + txn = self.client.txn() + try: + response = txn.query(query) + return json.loads(response.json) + finally: + txn.discard() + + def _process_publication_trends(self, data): + """Process publication trend data into a more usable format""" + trends = data.get('publication_trends', []) + processed_trends = [] + + for trend in trends: + processed_trends.append({ + 'month': trend.get('month'), + 'article_count': trend.get('article_count', 0) + }) + + # Sort by month + processed_trends.sort(key=lambda x: x['month'] if x['month'] else '') + + return { + 'trends': processed_trends, + 'total_months': len(processed_trends), + 'peak_month': max(processed_trends, key=lambda x: x['article_count']) if processed_trends else None + } + +``` + + + + + +```javascript +const dgraph = require("dgraph-js") +const grpc = require("grpc") +const { URL } = require('url') + +class NewsGraphJS { + constructor(connectionString = "dgraph://") { + /** + * Initialize with Dgraph connection string. + * Examples: + * - dgraph://localhost:9080 (local development) + * - dgraph://dgraph.example.com:443?ssl=true (production with SSL) + */ + this.connectionString = connectionString + this.client = this._createClient(connectionString) + } + + _createClient(connectionString) { + + const dgraphClient = await dgraph.open( + 'dgraph://', + ) + return dgraphClient + } + + async searchArticlesByTopic(topicName, limit = 10) { + /** + * Search articles using full-text search on topic names + */ + const query = ` + { + topics(func: anyoftext(Topic.name, "${topicName}")) { + Topic.name + articles: ~Article.topic (first: ${limit}) { + uid + Article.title + Article.abstract + Article.published + Article.uri + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async searchArticlesByContent(searchTerms, limit = 10) { + /** + * Full-text search across article titles and abstracts + */ + const query = ` + { + articles(func: anyoftext(Article.title, "${searchTerms}"), first: ${limit}) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async getRecentArticles(daysBack = 30, limit = 20) { + /** + * Get articles published within the last N days + */ + const cutoffDate = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1000).toISOString() + + const query = ` + { + recent_articles(func: type(Article)) @filter(ge(Article.published, "${cutoffDate}")) + (orderdesc: Article.published, first: ${limit}) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + Article.geo { + Geo.name + Geo.location + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async searchArticlesNearLocation(latitude, longitude, radiusMeters = 50000, limit = 10) { + /** + * Find articles associated with locations near given coordinates + */ + const query = ` + { + nearby_locations(func: near(Geo.location, [${longitude}, ${latitude}], ${radiusMeters})) { + Geo.name + Geo.location + articles: ~Article.geo (first: ${limit}) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async vectorSimilaritySearch(embeddingVector, limit = 5) { + /** + * Perform semantic search using article embeddings + */ + const query = ` + query vector_search($embedding: string, $limit: int) { + articles(func: similar_to(Article.embedding, $limit, $embedding)) { + uid + Article.title + Article.abstract + Article.published + score + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } + } + ` + + const variables = { + $embedding: JSON.stringify(embeddingVector), + $limit: limit.toString() + } + + const txn = this.client.newTxn() + try { + const response = await txn.queryWithVars(query, variables) + return response.getJson() + } finally { + await txn.discard() + } + } + + async getTopicStatistics() { + /** + * Get comprehensive statistics for each topic + */ + const query = ` + { + topic_statistics(func: type(Topic)) @filter(has(~Article.topic)) { + Topic.name + total_articles: count(~Article.topic) + recent_articles: count(~Article.topic @filter(ge(Article.published, "2025-01-01T00:00:00Z"))) + oldest_article: min(val(~Article.topic)) { + Article.published + } + newest_article: max(val(~Article.topic)) { + Article.published + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async complexFilteredSearch(contentTerms, topicTerms = null, sinceDate = "2025-01-01", hasLocation = false) { + /** + * Advanced search combining multiple filters and conditions + */ + const locationFilter = hasLocation ? "AND has(Article.geo)" : "" + const topicFilter = topicTerms ? `AND anyoftext(Article.topic, "${topicTerms}")` : "" + + const query = ` + { + filtered_articles(func: type(Article)) @filter( + anyoftext(Article.abstract, "${contentTerms}") AND + ge(Article.published, "${sinceDate}T00:00:00Z") + ${topicFilter} + ${locationFilter} + ) @cascade { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.geo { + Geo.name + Geo.location + } + Article.org { + Organization.name + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async analyzePublicationTrends() { + /** + * Analyze publication patterns over time using groupby + */ + const query = ` + { + publication_trends(func: type(Article)) @groupby(Article.published) { + month: datetrunc(Article.published, "month") + article_count: count(uid) + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + const data = response.getJson() + return this._processPublicationTrends(data) + } finally { + await txn.discard() + } + } + + async getNormalizedArticleData(limit = 10) { + /** + * Get flattened article data using @normalize + */ + const query = ` + { + articles(func: type(Article), first: ${limit}) @normalize { + title: Article.title + abstract: Article.abstract + published: Article.published + uri: Article.uri + topics: Article.topic { + name: Topic.name + } + organizations: Article.org { + name: Organization.name + } + location: Article.geo { + name: Geo.name + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async testConnection() { + /** + * Test the Dgraph connection + */ + try { + const query = "{ test(func: type(Article), first: 1) { uid } }" + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return { + status: "connected", + connectionString: this.connectionString, + response: "OK" + } + } finally { + await txn.discard() + } + } catch (error) { + return { + status: "error", + connectionString: this.connectionString, + error: error.message + } + } + } + + _processPublicationTrends(data) { + /** + * Process publication trend data into a more usable format + */ + const trends = data.publication_trends || [] + const processedTrends = trends.map(trend => ({ + month: trend.month, + article_count: trend.article_count || 0 + })) + + // Sort by month + processedTrends.sort((a, b) => { + if (!a.month) return 1 + if (!b.month) return -1 + return a.month.localeCompare(b.month) + }) + + const peakMonth = processedTrends.length > 0 + ? processedTrends.reduce((max, trend) => + trend.article_count > max.article_count ? trend : max + ) + : null + + return { + trends: processedTrends, + total_months: processedTrends.length, + peak_month: peakMonth + } + } + + // Legacy methods for backward compatibility + async searchCompanyNews(companyName, daysBack = 30) { + /** + * Legacy method: search for organization-related articles + */ + const query = ` + { + company_news(func: anyoftext(Organization.name, "${companyName}")) { + Organization.name + recent_mentions: ~Article.org @filter(gt(Article.published, "2024-01-01")) (first: 20) { + Article.title + Article.published + Article.abstract + Article.topic { + Topic.name + } + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return response.getJson() + } finally { + await txn.discard() + } + } + + async analyzeCompetitiveLandscape(companies) { + /** + * Legacy method: analyze competitive mentions across companies + */ + const query = ` + { + var(func: anyoftext(Organization.name, "${companies.join(" ")}")) { + competitor_articles as ~Article.org { + other_competitors: Article.org @filter(anyoftext(Organization.name, "${companies.join(" ")}")) + } + } + + competitive_analysis(func: uid(competitor_articles)) { + Article.title + Article.published + Article.abstract + companies_mentioned: Article.org @filter(anyoftext(Organization.name, "${companies.join(" ")}")) { + Organization.name + } + } + } + ` + + const txn = this.client.newTxn() + try { + const response = await txn.query(query) + return this.processCompetitiveData(response.getJson()) + } finally { + await txn.discard() + } + } + + processCompetitiveData(data) { + /** + * Process competitive analysis data + */ + const articles = data.competitive_analysis || [] + const companyMentions = {} + + articles.forEach((article) => { + article.companies_mentioned?.forEach((company) => { + if (!companyMentions[company["Organization.name"]]) { + companyMentions[company["Organization.name"]] = { + total_mentions: 0, + articles: [], + } + } + companyMentions[company["Organization.name"]].total_mentions++ + companyMentions[company["Organization.name"]].articles.push(article) + }) + }) + + return { + analysis_date: new Date().toISOString(), + companies_analyzed: Object.keys(companyMentions), + competitive_insights: companyMentions, + total_articles_analyzed: articles.length, + } + } +} + +// Usage examples with different connection strings +async function exampleUsage() { + try { + // Local development + const localAgent = new NewsGraphJS("dgraph://localhost:9080") + + // Production with SSL + const prodAgent = new NewsGraphJS("dgraph://dgraph.example.com:443?ssl=true") + + // Test connections + console.log("Local connection:", await localAgent.testConnection()) + console.log("Production connection:", await prodAgent.testConnection()) + + // Use the agent + const recentArticles = await localAgent.getRecentArticles(7, 5) + console.log("Recent articles:", JSON.stringify(recentArticles, null, 2)) + + // Search by topic + const techArticles = await localAgent.searchArticlesByTopic("technology") + console.log("Tech articles:", JSON.stringify(techArticles, null, 2)) + + // Get topic statistics + const topicStats = await localAgent.getTopicStatistics() + console.log("Topic statistics:", JSON.stringify(topicStats, null, 2)) + + } catch (error) { + console.error("Error:", error.message) + } +} + +module.exports = { NewsGraphJS, exampleUsage } + +``` + +{/* */} + + + + + +```go +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "net/url" + "strconv" + "strings" + "time" + + "github.com/dgraph-io/dgo/v2" + "github.com/dgraph-io/dgo/v2/protos/api" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" +) + +type NewsGraphGo struct { + client *dgo.Dgraph + connectionString string +} + +// NewNewsGraphClient creates a new Dgraph client with connection string support +func NewNewsGraphClient(connectionString string) (*NewsGraphGo, error) { + if connectionString == "" { + connectionString = "dgraph://localhost:9080" + } + + client, err := dgo.Open(connectionString) + if err != nil { + return nil, fmt.Errorf("failed to create Dgraph client: %v", err) + } + + return &NewsGraphGo{ + client: client, + connectionString: connectionString, + }, nil +} + +// SearchArticlesByTopic searches articles using full-text search on topic names +func (ng *NewsGraphGo) SearchArticlesByTopic(topicName string, limit int) (*TopicSearchResult, error) { + query := fmt.Sprintf(` + { + topics(func: anyoftext(Topic.name, "%s")) { + Topic.name + articles: ~Article.topic (first: %d) { + uid + Article.title + Article.abstract + Article.published + Article.uri + } + } + } + `, topicName, limit) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result TopicSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// SearchArticlesByContent performs full-text search across article titles and abstracts +func (ng *NewsGraphGo) SearchArticlesByContent(searchTerms string, limit int) (*ArticleSearchResult, error) { + query := fmt.Sprintf(` + { + articles(func: anyoftext(Article.title, "%s"), first: %d) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } + } + `, searchTerms, limit) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result ArticleSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// GetRecentArticles gets articles published within the last N days +func (ng *NewsGraphGo) GetRecentArticles(daysBack, limit int) (*ArticleSearchResult, error) { + cutoffDate := time.Now().AddDate(0, 0, -daysBack).Format(time.RFC3339) + + query := fmt.Sprintf(` + { + recent_articles(func: type(Article)) @filter(ge(Article.published, "%s")) + (orderdesc: Article.published, first: %d) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + Article.geo { + Geo.name + Geo.location + } + } + } + `, cutoffDate, limit) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result ArticleSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// SearchArticlesNearLocation finds articles associated with locations near given coordinates +func (ng *NewsGraphGo) SearchArticlesNearLocation(latitude, longitude float64, radiusMeters, limit int) (*LocationSearchResult, error) { + query := fmt.Sprintf(` + { + nearby_locations(func: near(Geo.location, [%f, %f], %d)) { + Geo.name + Geo.location + articles: ~Article.geo (first: %d) { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + } + } + } + `, longitude, latitude, radiusMeters, limit) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result LocationSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// VectorSimilaritySearch performs semantic search using article embeddings +func (ng *NewsGraphGo) VectorSimilaritySearch(embeddingVector []float64, limit int) (*VectorSearchResult, error) { + // Convert embedding vector to string format + embeddingJSON, err := json.Marshal(embeddingVector) + if err != nil { + return nil, fmt.Errorf("failed to marshal embedding vector: %v", err) + } + + query := ` + query vector_search($embedding: string, $limit: int) { + articles(func: similar_to(Article.embedding, $limit, $embedding)) { + uid + Article.title + Article.abstract + Article.published + score + Article.topic { + Topic.name + } + Article.org { + Organization.name + } + } + } + ` + + variables := map[string]string{ + "$embedding": string(embeddingJSON), + "$limit": strconv.Itoa(limit), + } + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.QueryWithVars(context.Background(), query, variables) + if err != nil { + return nil, err + } + + var result VectorSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// GetTopicStatistics gets comprehensive statistics for each topic +func (ng *NewsGraphGo) GetTopicStatistics() (*TopicStatsResult, error) { + query := ` + { + topic_statistics(func: type(Topic)) @filter(has(~Article.topic)) { + Topic.name + total_articles: count(~Article.topic) + recent_articles: count(~Article.topic @filter(ge(Article.published, "2025-01-01T00:00:00Z"))) + oldest_article: min(val(~Article.topic)) { + Article.published + } + newest_article: max(val(~Article.topic)) { + Article.published + } + } + } + ` + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result TopicStatsResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// ComplexFilteredSearch performs advanced search combining multiple filters and conditions +func (ng *NewsGraphGo) ComplexFilteredSearch(contentTerms string, topicTerms *string, sinceDate string, hasLocation bool) (*ArticleSearchResult, error) { + locationFilter := "" + if hasLocation { + locationFilter = "AND has(Article.geo)" + } + + topicFilter := "" + if topicTerms != nil { + topicFilter = fmt.Sprintf(`AND anyoftext(Article.topic, "%s")`, *topicTerms) + } + + query := fmt.Sprintf(` + { + filtered_articles(func: type(Article)) @filter( + anyoftext(Article.abstract, "%s") AND + ge(Article.published, "%sT00:00:00Z") + %s + %s + ) @cascade { + uid + Article.title + Article.abstract + Article.published + Article.topic { + Topic.name + } + Article.geo { + Geo.name + Geo.location + } + Article.org { + Organization.name + } + } + } + `, contentTerms, sinceDate, topicFilter, locationFilter) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result ArticleSearchResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// AnalyzePublicationTrends analyzes publication patterns over time using groupby +func (ng *NewsGraphGo) AnalyzePublicationTrends() (*PublicationTrendsResult, error) { + query := ` + { + publication_trends(func: type(Article)) @groupby(Article.published) { + month: datetrunc(Article.published, "month") + article_count: count(uid) + } + } + ` + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var rawResult map[string]interface{} + err = json.Unmarshal(response.Json, &rawResult) + if err != nil { + return nil, err + } + + return ng.processPublicationTrends(rawResult), nil +} + +// GetNormalizedArticleData gets flattened article data using @normalize +func (ng *NewsGraphGo) GetNormalizedArticleData(limit int) (*NormalizedArticleResult, error) { + query := fmt.Sprintf(` + { + articles(func: type(Article), first: %d) @normalize { + title: Article.title + abstract: Article.abstract + published: Article.published + uri: Article.uri + topics: Article.topic { + name: Topic.name + } + organizations: Article.org { + name: Organization.name + } + location: Article.geo { + name: Geo.name + } + } + } + `, limit) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result NormalizedArticleResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +// TestConnection tests the Dgraph connection +func (ng *NewsGraphGo) TestConnection() *ConnectionStatus { + query := "{ test(func: type(Article), first: 1) { uid } }" + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + _, err := txn.Query(context.Background(), query) + if err != nil { + return &ConnectionStatus{ + Status: "error", + ConnectionString: ng.connectionString, + Error: err.Error(), + } + } + + return &ConnectionStatus{ + Status: "connected", + ConnectionString: ng.connectionString, + Response: "OK", + } +} + +// Helper method to process publication trends +func (ng *NewsGraphGo) processPublicationTrends(data map[string]interface{}) *PublicationTrendsResult { + trendsInterface, ok := data["publication_trends"].([]interface{}) + if !ok { + return &PublicationTrendsResult{ + Trends: []TrendData{}, + TotalMonths: 0, + } + } + + var trends []TrendData + var peakMonth *TrendData + + for _, trendInterface := range trendsInterface { + trendMap, ok := trendInterface.(map[string]interface{}) + if !ok { + continue + } + + trend := TrendData{ + Month: getString(trendMap, "month"), + ArticleCount: getInt(trendMap, "article_count"), + } + + trends = append(trends, trend) + + if peakMonth == nil || trend.ArticleCount > peakMonth.ArticleCount { + peakMonth = &trend + } + } + + return &PublicationTrendsResult{ + Trends: trends, + TotalMonths: len(trends), + PeakMonth: peakMonth, + } +} + +// Legacy methods for backward compatibility +func (ng *NewsGraphGo) SearchCompanyNews(companyName string, daysBack int) (*CompanyNewsResult, error) { + query := fmt.Sprintf(` + { + company_news(func: anyoftext(Organization.name, "%s")) { + Organization.name + recent_mentions: ~Article.org @filter(gt(Article.published, "2024-01-01")) (first: 20) { + Article.title + Article.published + Article.abstract + Article.topic { + Topic.name + } + } + } + } + `, companyName) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var result CompanyNewsResult + err = json.Unmarshal(response.Json, &result) + return &result, err +} + +func (ng *NewsGraphGo) AnalyzeCompetitiveLandscape(companies []string) (*CompetitiveAnalysisResult, error) { + companiesStr := strings.Join(companies, " ") + + query := fmt.Sprintf(` + { + var(func: anyoftext(Organization.name, "%s")) { + competitor_articles as ~Article.org { + other_competitors: Article.org @filter(anyoftext(Organization.name, "%s")) + } + } + + competitive_analysis(func: uid(competitor_articles)) { + Article.title + Article.published + Article.abstract + companies_mentioned: Article.org @filter(anyoftext(Organization.name, "%s")) { + Organization.name + } + } + } + `, companiesStr, companiesStr, companiesStr) + + txn := ng.client.NewTxn() + defer txn.Discard(context.Background()) + + response, err := txn.Query(context.Background(), query) + if err != nil { + return nil, err + } + + var rawResult map[string]interface{} + err = json.Unmarshal(response.Json, &rawResult) + if err != nil { + return nil, err + } + + return ng.processCompetitiveData(rawResult, companies), nil +} + +func (ng *NewsGraphGo) processCompetitiveData(data map[string]interface{}, companies []string) *CompetitiveAnalysisResult { + articlesInterface, ok := data["competitive_analysis"].([]interface{}) + if !ok { + articlesInterface = []interface{}{} + } + + companyMentions := make(map[string]*CompanyMention) + + for _, articleInterface := range articlesInterface { + articleMap, ok := articleInterface.(map[string]interface{}) + if !ok { + continue + } + + companiesInterface, ok := articleMap["companies_mentioned"].([]interface{}) + if !ok { + continue + } + + for _, companyInterface := range companiesInterface { + companyMap, ok := companyInterface.(map[string]interface{}) + if !ok { + continue + } + + companyName := getString(companyMap, "Organization.name") + if companyName == "" { + continue + } + + if _, exists := companyMentions[companyName]; !exists { + companyMentions[companyName] = &CompanyMention{ + TotalMentions: 0, + Articles: []map[string]interface{}{}, + } + } + + companyMentions[companyName].TotalMentions++ + companyMentions[companyName].Articles = append( + companyMentions[companyName].Articles, + articleMap, + ) + } + } + + var companiesAnalyzed []string + for company := range companyMentions { + companiesAnalyzed = append(companiesAnalyzed, company) + } + + return &CompetitiveAnalysisResult{ + AnalysisDate: time.Now().Format(time.RFC3339), + CompaniesAnalyzed: companiesAnalyzed, + CompetitiveInsights: companyMentions, + TotalArticlesAnalyzed: len(articlesInterface), + } +} + +// Helper functions +func getString(m map[string]interface{}, key string) string { + if val, ok := m[key].(string); ok { + return val + } + return "" +} + +func getInt(m map[string]interface{}, key string) int { + if val, ok := m[key].(float64); ok { + return int(val) + } + return 0 +} + +// Type definitions +type Article struct { + UID string `json:"uid"` + Title string `json:"Article.title"` + Abstract string `json:"Article.abstract"` + Published string `json:"Article.published"` + URI string `json:"Article.uri"` + Topic []Topic `json:"Article.topic"` + Org []Organization `json:"Article.org"` + Geo []Geo `json:"Article.geo"` +} + +type Topic struct { + Name string `json:"Topic.name"` +} + +type Organization struct { + Name string `json:"Organization.name"` +} + +type Geo struct { + Name string `json:"Geo.name"` + Location string `json:"Geo.location"` +} + +type TopicSearchResult struct { + Topics []struct { + Name string `json:"Topic.name"` + Articles []Article `json:"articles"` + } `json:"topics"` +} + +type ArticleSearchResult struct { + Articles []Article `json:"articles,omitempty"` + RecentArticles []Article `json:"recent_articles,omitempty"` + FilteredArticles []Article `json:"filtered_articles,omitempty"` +} + +type LocationSearchResult struct { + NearbyLocations []struct { + Name string `json:"Geo.name"` + Location string `json:"Geo.location"` + Articles []Article `json:"articles"` + } `json:"nearby_locations"` +} + +type VectorSearchResult struct { + Articles []struct { + Article + Score float64 `json:"score"` + } `json:"articles"` +} + +type TopicStatsResult struct { + TopicStatistics []struct { + Name string `json:"Topic.name"` + TotalArticles int `json:"total_articles"` + RecentArticles int `json:"recent_articles"` + OldestArticle []struct { + Published string `json:"Article.published"` + } `json:"oldest_article"` + NewestArticle []struct { + Published string `json:"Article.published"` + } `json:"newest_article"` + } `json:"topic_statistics"` +} + +type PublicationTrendsResult struct { + Trends []TrendData `json:"trends"` + TotalMonths int `json:"total_months"` + PeakMonth *TrendData `json:"peak_month"` +} + +type TrendData struct { + Month string `json:"month"` + ArticleCount int `json:"article_count"` +} + +type NormalizedArticleResult struct { + Articles []struct { + Title string `json:"title"` + Abstract string `json:"abstract"` + Published string `json:"published"` + URI string `json:"uri"` + Topics []struct { + Name string `json:"name"` + } `json:"topics"` + Organizations []struct { + Name string `json:"name"` + } `json:"organizations"` + Location []struct { + Name string `json:"name"` + } `json:"location"` + } `json:"articles"` +} + +type ConnectionStatus struct { + Status string `json:"status"` + ConnectionString string `json:"connection_string"` + Response string `json:"response,omitempty"` + Error string `json:"error,omitempty"` +} + +type CompanyNewsResult struct { + CompanyNews []struct { + Name string `json:"Organization.name"` + RecentMentions []Article `json:"recent_mentions"` + } `json:"company_news"` +} + +type CompetitiveAnalysisResult struct { + AnalysisDate string `json:"analysis_date"` + CompaniesAnalyzed []string `json:"companies_analyzed"` + CompetitiveInsights map[string]*CompanyMention `json:"competitive_insights"` + TotalArticlesAnalyzed int `json:"total_articles_analyzed"` +} + +type CompanyMention struct { + TotalMentions int `json:"total_mentions"` + Articles []map[string]interface{} `json:"articles"` +} + +// Example usage +func ExampleUsage() { + // Local development + localAgent, err := NewNewsGraphClient("dgraph://localhost:9080") + if err != nil { + log.Fatal("Failed to create local client:", err) + } + + // Production with SSL + prodAgent, err := NewNewsGraphClient("dgraph://dgraph.example.com:443?ssl=true") + if err != nil { + log.Fatal("Failed to create production client:", err) + } + + // Test connections + fmt.Println("Local connection:", localAgent.TestConnection()) + fmt.Println("Production connection:", prodAgent.TestConnection()) + + // Use the agent + recentArticles, err := localAgent.GetRecentArticles(7, 5) + if err != nil { + log.Printf("Error getting recent articles: %v", err) + } else { + fmt.Printf("Recent articles: %+v\n", recentArticles) + } + + // Search by topic + techArticles, err := localAgent.SearchArticlesByTopic("technology", 10) + if err != nil { + log.Printf("Error searching by topic: %v", err) + } else { + fmt.Printf("Tech articles: %+v\n", techArticles) + } + + // Get topic statistics + topicStats, err := localAgent.GetTopicStatistics() + if err != nil { + log.Printf("Error getting topic statistics: %v", err) + } else { + fmt.Printf("Topic statistics: %+v\n", topicStats) + } +} + +func main() { + ExampleUsage() +} + +``` + +{/* */} + + + + +## What you've accomplished + +In 30 minutes, you've mastered advanced graph querying: + +**DQL mastery**: learned sophisticated query patterns for graph traversal and +analysis + +**Ratel exploration**: used visual tools to understand graph structure and +optimize queries + +**Multi-language integration**: implemented Dgraph clients in Python, +JavaScript, and Go + +**Agent integration**: connected graph reasoning capabilities to intelligent +agents + +**Advanced patterns**: built complex analysis workflows using graph-native +operations + +## The power of graph querying + +DQL enables reasoning that traditional databases can't: + +**Traditional queries**: "What articles mention OpenAI?" + +**Graph-powered queries**: "What entities are connected to OpenAI through 2-3 +degrees of separation, how has this network evolved over time, and what does the +pattern suggest about competitive positioning?" + +This completes your mastery of context engineering fundamentals. + + + You've mastered context engineering - from prompts to sophisticated graph + reasoning. Ready for production deployment in Week 5! + + +## Pro tip for today + +Build a comprehensive graph analysis workflow: + +```text +Create a complete analysis workflow that: +1. Takes a business question (e.g., "How is the AI industry competitive landscape evolving?") +2. Extracts relevant entities and relationships from the question +3. Designs appropriate DQL queries to explore the graph +4. Analyzes patterns across multiple dimensions (temporal, network, sentiment) +5. Synthesizes insights that answer the original business question +6. Explains the graph reasoning behind each conclusion + +Show me both the technical implementation and the business insights it reveals. +``` + +This demonstrates the full power of graph-powered agent reasoning. + +--- + +**Time to complete**: ~30 minutes + +**Skills learned** DQL mastery, Ratel exploration, multi-language client +integration, graph-powered agent reasoning, advanced analysis workflows + +**Week 4 complete**: context engineering mastery achieved! + + + **Remember** Graph querying is about following the connections that reveal + hidden insights. The most valuable discoveries often come from relationships + that weren't obvious until you traversed the graph. + +```` diff --git a/docs.json b/docs.json index 35246119..10528c89 100644 --- a/docs.json +++ b/docs.json @@ -130,6 +130,19 @@ "agents/30-days-of-agents/day-14", "agents/30-days-of-agents/day-15" ] + }, + { + "group": "Week 4", + "pages": [ + "agents/30-days-of-agents/context-engineering", + "agents/30-days-of-agents/day-16", + "agents/30-days-of-agents/day-17", + "agents/30-days-of-agents/day-18", + "agents/30-days-of-agents/day-19", + "agents/30-days-of-agents/day-20", + "agents/30-days-of-agents/day-21", + "agents/30-days-of-agents/day-22" + ] } ] }, diff --git a/images/agents/30-days-of-agents/day-21-graph-model.png b/images/agents/30-days-of-agents/day-21-graph-model.png new file mode 100644 index 00000000..53df33a6 Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-graph-model.png differ diff --git a/images/agents/30-days-of-agents/day-21-hypermode-1.png b/images/agents/30-days-of-agents/day-21-hypermode-1.png new file mode 100644 index 00000000..c34c6cd4 Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-hypermode-1.png differ diff --git a/images/agents/30-days-of-agents/day-21-hypermode-2.png b/images/agents/30-days-of-agents/day-21-hypermode-2.png new file mode 100644 index 00000000..3820a1bf Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-hypermode-2.png differ diff --git a/images/agents/30-days-of-agents/day-21-hypermode-3.png b/images/agents/30-days-of-agents/day-21-hypermode-3.png new file mode 100644 index 00000000..a39016d6 Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-hypermode-3.png differ diff --git a/images/agents/30-days-of-agents/day-21-hypermode-4.png b/images/agents/30-days-of-agents/day-21-hypermode-4.png new file mode 100644 index 00000000..a4614041 Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-hypermode-4.png differ diff --git a/images/agents/30-days-of-agents/day-21-ratel-query.png b/images/agents/30-days-of-agents/day-21-ratel-query.png new file mode 100644 index 00000000..f6b786dc Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-ratel-query.png differ diff --git a/images/agents/30-days-of-agents/day-21-ratel-update-schema.png b/images/agents/30-days-of-agents/day-21-ratel-update-schema.png new file mode 100644 index 00000000..f3c0c825 Binary files /dev/null and b/images/agents/30-days-of-agents/day-21-ratel-update-schema.png differ diff --git a/styles/config/vocabularies/general/accept.txt b/styles/config/vocabularies/general/accept.txt index ab74b747..234b05ab 100644 --- a/styles/config/vocabularies/general/accept.txt +++ b/styles/config/vocabularies/general/accept.txt @@ -2,6 +2,7 @@ [Aa]gentic Ahrefs Airtable +[Aa]rticle [Aa]lterSchema [Aa]pp Asana @@ -9,14 +10,19 @@ Attio Basecamp [Bb]oolean [Bb]ootcamp +[Bb]rowser Browserbase [Cc]ollections [Cc]omputeDistance [Cc]omputeSimilarity [Cc]onsole +(?i)CLEAR CRM [Cc]ryptocurrency +[Cc]ypher +datetime [Dd]eserialize +Dgraph [Dd]istilbert [Dd]ropAll [Dd]ropAttr @@ -31,10 +37,12 @@ FAQs [Gg]etText [Gg]etTexts [Gg]etVector +GraphRAG [Hh]ardcoding [Hh]yp [Hh]ypercategories [Hh]ypermode +HNSW Hyperbrowser [Ii]nferencing Jira @@ -84,10 +92,12 @@ ISO LLM Logf MySQL|mysql +[Nn]eo4j NPM|npm NQuads|nquads PostgreSQL|postgresql PUT +(?i)RAG recompiles repo RDF @@ -100,9 +110,12 @@ Strava Supabase TLS tokenizer +[Tt]ransformative URL|url UTC urql +URI +URIs UUID Warnf WASM @@ -200,7 +213,7 @@ CRM CRMs touchpoints Neo4j -Geospatial +[Gg]eospatial Linear MRR LTV