# O-RedSearch - Revolutionary Decentralized Search Engine --- ## 🌐 Language Navigation **[πŸ‡«πŸ‡· FranΓ§ais](../docs/oredsearch-engine.md#franΓ§ais)** | **[πŸ‡¬πŸ‡§ English](#english)** | **[πŸ‡ͺπŸ‡Έ EspaΓ±ol](#espaΓ±ol)** | **[πŸ‡¨πŸ‡³ δΈ­ζ–‡](#δΈ­ζ–‡)** --- ## English ### πŸ“œ [O-RED MANIFESTO - INVIOLABLE CHARTER](MANIFESTO.md) **Fully respects the inviolable principles of the O-Red ecosystem** ## Revolutionary Vision O-RedSearch is the first fully decentralized search engine that respects your privacy: indexing is distributed among users and your personal AI, O-RedMind, improves your results without ever revealing your searches to anyone. ## Disruptive Paradigm ### πŸ” Decentralized Search vs Centralized Engines | Aspect | Centralized Engines (Google, Bing) | O-RedSearch (Decentralized) | |--------|-------------------------------------|----------------------------| | **Indexing** | Proprietary central servers | Distributed P2P index | | **Privacy** | Massive tracking and profiling | 100% anonymous searches | | **Results** | Manipulated by secret algorithms | Objective and transparent relevance | | **Censorship** | Possible and frequent | Technically impossible | | **Data** | Collected and monetized | Never stored or transmitted | | **AI** | Serves the engine's interests | Your personal AI only | | **Advertising** | Omnipresent and intrusive | Zero advertising | | **Open Source** | Secret algorithms | 100% transparent and auditable | ## Revolutionary Architecture ### πŸ—οΈ Decentralized Infrastructure ``` 🌐 O-RedSearch Ecosystem β”œβ”€β”€ πŸ•·οΈ Distributed Web Crawling β”‚ β”œβ”€β”€ Node-based Crawlers β”‚ β”œβ”€β”€ Federated Discovery β”‚ β”œβ”€β”€ Content Verification β”‚ └── Quality Assessment β”œβ”€β”€ πŸ“Š Distributed Indexing β”‚ β”œβ”€β”€ Peer-to-Peer Index Shards β”‚ β”œβ”€β”€ Semantic Understanding β”‚ β”œβ”€β”€ Multi-language Support β”‚ └── Real-time Updates β”œβ”€β”€ πŸ” Search Processing β”‚ β”œβ”€β”€ Query Distribution β”‚ β”œβ”€β”€ Result Aggregation β”‚ β”œβ”€β”€ Relevance Ranking β”‚ └── Personal AI Integration β”œβ”€β”€ πŸ€– AI Enhancement Layer β”‚ β”œβ”€β”€ O-RedMind Integration β”‚ β”œβ”€β”€ Personalized Results β”‚ β”œβ”€β”€ Context Understanding β”‚ └── Learning from Usage β”œβ”€β”€ πŸ”’ Privacy Protection β”‚ β”œβ”€β”€ Anonymous Queries β”‚ β”œβ”€β”€ Zero-Knowledge Search β”‚ β”œβ”€β”€ No Data Storage β”‚ └── Encrypted Communications └── 🌍 Content Network β”œβ”€β”€ Public Web Indexing β”œβ”€β”€ O-Red Network Content β”œβ”€β”€ Academic Resources └── Open Data Sources ``` ### πŸ•ΈοΈ Decentralized Crawling #### Distributed Crawling Architecture ```python class DistributedWebCrawler: def __init__(self, node_id): self.node_id = node_id self.crawler_pool = CrawlerPool() self.content_validator = ContentValidator() self.deduplicator = ContentDeduplicator() self.quality_assessor = QualityAssessor() def coordinate_crawling(self, crawling_strategy): # Smart domain allocation domain_assignments = self.distribute_domains( available_nodes=self.get_active_crawler_nodes(), crawling_priorities=crawling_strategy.priorities, node_capabilities=self.assess_node_capabilities() ) # Launch distributed crawling crawl_results = [] for assignment in domain_assignments: crawl_result = self.execute_distributed_crawl( target_domains=assignment.domains, assigned_nodes=assignment.nodes, crawl_depth=assignment.depth, quality_threshold=crawling_strategy.min_quality ) crawl_results.append(crawl_result) # Aggregate and validate validated_content = self.validate_and_deduplicate(crawl_results) return validated_content def crawl_with_respect(self, target_url, robots_policy): # Strict respect for robots.txt and crawling policies if not self.can_crawl(target_url, robots_policy): return None # Polite crawling with throttling content = self.respectful_crawl( url=target_url, delay=robots_policy.crawl_delay, user_agent="O-RedSearch/1.0 (Decentralized Search)", respect_rate_limits=True ) # Quality evaluation quality_score = self.quality_assessor.assess(content) if quality_score >= self.minimum_quality_threshold: return self.prepare_for_indexing(content, quality_score) return None ``` #### Content Quality System ```python class ContentQualityAssessment: def __init__(self): self.spam_detector = SpamDetector() self.factcheck_engine = FactCheckEngine() self.readability_analyzer = ReadabilityAnalyzer() self.authority_scorer = AuthorityScorer() def assess_content_quality(self, content, source_info): quality_metrics = { 'spam_score': self.spam_detector.detect_spam(content), 'factual_accuracy': self.factcheck_engine.verify_facts(content), 'readability': self.readability_analyzer.analyze(content), 'source_authority': self.authority_scorer.score_source(source_info), 'content_originality': self.check_originality(content), 'information_density': self.calculate_info_density(content) } # Composite quality score quality_score = self.calculate_composite_score(quality_metrics) # Content classification content_classification = self.classify_content_type(content) return { 'quality_score': quality_score, 'metrics': quality_metrics, 'classification': content_classification, 'indexing_priority': self.determine_indexing_priority(quality_score) } ``` ### πŸ“Š Distributed Indexing #### Index Shard Distribution ```python class DistributedIndexManager: def __init__(self, network_nodes): self.nodes = network_nodes self.shard_coordinator = ShardCoordinator() self.consistency_manager = ConsistencyManager() self.replication_handler = ReplicationHandler() def create_distributed_index(self, crawled_content): # Intelligent semantic partitioning content_shards = self.semantic_partitioning( content=crawled_content, shard_strategy='semantic_clustering', target_shard_size=self.optimal_shard_size() ) # Optimal geographical distribution shard_assignments = self.optimize_shard_distribution( shards=content_shards, nodes=self.nodes, criteria=['geographic_proximity', 'node_capacity', 'network_latency'] ) # Replication for resilience replicated_assignments = self.replication_handler.add_redundancy( assignments=shard_assignments, replication_factor=3, # Each shard replicated 3 times failure_tolerance=0.33 # Tolerates 33% node failures ) # Distributed deployment deployment_results = [] for assignment in replicated_assignments: result = self.deploy_shard_to_nodes( shard=assignment.shard, target_nodes=assignment.nodes, consistency_level='eventual' # Eventual consistency for performance ) deployment_results.append(result) # Create metadata index metadata_index = self.create_metadata_index(deployment_results) return { 'index_id': self.generate_index_id(), 'shard_distribution': deployment_results, 'metadata_index': metadata_index, 'query_routing_table': self.build_routing_table(deployment_results) } def semantic_partitioning(self, content, shard_strategy, target_shard_size): # Semantic analysis of content semantic_clusters = self.analyze_semantic_clusters(content) # Topic-based partitioning topic_shards = [] for cluster in semantic_clusters: if cluster.content_size > target_shard_size: # Subdivide large clusters sub_shards = self.subdivide_cluster(cluster, target_shard_size) topic_shards.extend(sub_shards) else: topic_shards.append(cluster) # Optimize shards optimized_shards = self.optimize_shard_balance(topic_shards) return optimized_shards ``` ### πŸ” Query Processing #### Query Processing Engine ```python class SearchQueryProcessor: def __init__(self, ored_mind_api): self.ai = ored_mind_api self.query_analyzer = QueryAnalyzer() self.intent_detector = IntentDetector() self.query_expander = QueryExpander() self.result_ranker = ResultRanker() def process_search_query(self, query, user_context): # Analyze and understand the query query_analysis = self.analyze_query(query, user_context) # Detect user intent search_intent = self.intent_detector.detect_intent( query=query, user_history=user_context.search_history, current_profile=user_context.active_profile ) # Expand query with personal AI expanded_query = self.ai.expand_search_query( original_query=query, intent=search_intent, personal_context=user_context.personal_interests, domain_expertise=user_context.expertise_areas ) # Create distributed search plan distributed_search_plan = self.create_search_plan( expanded_query=expanded_query, target_shards=self.identify_relevant_shards(expanded_query), search_depth=search_intent.depth_requirement ) # Execute distributed search search_results = self.execute_distributed_search(distributed_search_plan) # Aggregate and personalized ranking aggregated_results = self.aggregate_results(search_results) personalized_ranking = self.ai.personalize_results( results=aggregated_results, user_preferences=user_context.preferences, expertise_level=user_context.expertise_level ) return { 'results': personalized_ranking.results, 'query_suggestions': self.generate_suggestions(expanded_query), 'related_topics': self.ai.suggest_related_topics(query), 'search_insights': self.ai.generate_search_insights(query, search_results) } def analyze_query(self, query, user_context): return { 'query_type': self.classify_query_type(query), 'language': self.detect_language(query), 'entities': self.extract_entities(query), 'keywords': self.extract_keywords(query), 'complexity': self.assess_complexity(query), 'domain': self.detect_domain(query, user_context) } ``` ### πŸ€– Personal AI Integration #### O-RedMind Search Enhancement ```python class PersonalizedSearchAI: def __init__(self, user_profile): self.user_profile = user_profile self.learning_engine = PersonalSearchLearning() self.context_manager = SearchContextManager() self.relevance_predictor = PersonalRelevancePredictor() def enhance_search_experience(self, query, search_context): # Build personal contextual understanding personal_context = self.context_manager.build_personal_context( current_query=query, user_profile=self.user_profile, recent_activities=search_context.recent_activities, current_projects=search_context.active_projects ) # Predict personalized relevance relevance_model = self.relevance_predictor.get_personal_model( user_id=self.user_profile.id, domain=personal_context.domain ) # Enhance query with context enhanced_query = self.enhance_query_with_context( original_query=query, personal_context=personal_context, expertise_level=self.user_profile.expertise_level ) return { 'enhanced_query': enhanced_query, 'personal_context': personal_context, 'relevance_model': relevance_model, 'search_strategies': self.suggest_search_strategies(personal_context) } def learn_from_search_behavior(self, search_session): # Learn search preferences search_patterns = self.analyze_search_patterns(search_session) # Update personal model self.learning_engine.update_personal_model( user_id=self.user_profile.id, search_patterns=search_patterns, satisfaction_feedback=search_session.user_feedback ) # Continuous improvement self.relevance_predictor.retrain_personal_model( user_id=self.user_profile.id, new_training_data=search_session.interaction_data ) ``` ## Revolutionary Features ### πŸ”’ 100% Anonymous Search #### Zero-Knowledge Search Protocol ```python class AnonymousSearchProtocol: def __init__(self): self.query_obfuscator = QueryObfuscator() self.traffic_mixer = TrafficMixer() self.result_anonymizer = ResultAnonymizer() def execute_anonymous_search(self, query, user_preferences): # Obfuscate the query obfuscated_query = self.query_obfuscator.obfuscate( original_query=query, noise_level='high', decoy_queries=self.generate_decoy_queries(query) ) # Anonymous routing anonymous_routing = self.create_anonymous_routing( query=obfuscated_query, target_nodes=self.select_search_nodes(), anonymization_layers=3 # Triple anonymization ) # Mix traffic mixed_traffic = self.traffic_mixer.mix_search_traffic( real_query=anonymous_routing, dummy_traffic=self.generate_dummy_searches(), timing_obfuscation=True ) # Execute and de-obfuscate raw_results = self.execute_search_through_mixnet(mixed_traffic) clean_results = self.result_anonymizer.clean_results( raw_results=raw_results, remove_tracking=True, sanitize_urls=True ) return clean_results ``` ### 🌍 Intelligent Multilingual Search #### Universal Language Search ```python class MultilingualSearchEngine: def __init__(self): self.language_detector = LanguageDetector() self.cross_lingual_search = CrossLingualSearch() self.translation_engine = DecentralizedTranslation() self.cultural_adapter = CulturalContextAdapter() def search_across_languages(self, query, target_languages=None): # Detect query language query_language = self.language_detector.detect(query) # Determine target languages if none are provided if target_languages is None: target_languages = self.suggest_relevant_languages(query) multilingual_results = [] for lang in target_languages: # Contextual translation of the query translated_query = self.translation_engine.translate_query( query=query, source_lang=query_language, target_lang=lang, preserve_intent=True ) # Search in the target language lang_results = self.search_in_language(translated_query, lang) # Culturally adapt results culturally_adapted = self.cultural_adapter.adapt_results( results=lang_results, target_culture=lang, user_cultural_context=self.get_user_cultural_context() ) multilingual_results.append({ 'language': lang, 'results': culturally_adapted, 'query_translation': translated_query }) # Merge multilingual results unified_results = self.merge_multilingual_results(multilingual_results) return unified_results ``` ### πŸ” Advanced Semantic Search #### Semantic Understanding Engine ```python class SemanticSearchEngine: def __init__(self): self.concept_extractor = ConceptExtractor() self.knowledge_graph = DecentralizedKnowledgeGraph() self.semantic_matcher = SemanticMatcher() self.context_reasoner = ContextualReasoner() def semantic_search(self, query, search_context): # Extract concepts query_concepts = self.concept_extractor.extract(query) # Expand via knowledge graph expanded_concepts = self.knowledge_graph.expand_concepts( concepts=query_concepts, expansion_depth=2, relevance_threshold=0.7 ) # Semantic matching semantic_matches = self.semantic_matcher.find_matches( concepts=expanded_concepts, content_index=self.get_semantic_index(), matching_algorithm='transformer_similarity' ) # Contextual reasoning contextualized_results = self.context_reasoner.reason_about_results( matches=semantic_matches, query_context=search_context, user_background=search_context.user_expertise ) return { 'semantic_results': contextualized_results, 'concept_graph': expanded_concepts, 'reasoning_path': self.context_reasoner.get_reasoning_explanation() } ``` ### πŸ“Š Open Data Search #### Open Data Integration ```python class OpenDataSearchIntegration: def __init__(self): self.data_source_registry = OpenDataSourceRegistry() self.data_harmonizer = DataHarmonizer() self.visualization_engine = DataVisualizationEngine() def search_open_data(self, query, data_preferences): # Identify relevant data sources relevant_sources = self.data_source_registry.find_sources( query_domain=self.extract_domain(query), data_types=data_preferences.preferred_types, quality_threshold=data_preferences.min_quality ) # Query each data source data_results = [] for source in relevant_sources: source_data = self.query_data_source( source=source, query=self.adapt_query_for_source(query, source), result_limit=data_preferences.max_results_per_source ) data_results.append(source_data) # Harmonize data harmonized_data = self.data_harmonizer.harmonize( data_results=data_results, target_schema=self.determine_target_schema(query), quality_filters=data_preferences.quality_filters ) # Auto-generate visualizations if requested if data_preferences.auto_visualize: visualizations = self.visualization_engine.create_visualizations( data=harmonized_data, visualization_types=self.suggest_visualization_types(harmonized_data) ) harmonized_data['visualizations'] = visualizations return harmonized_data ``` ## Revolutionary User Interface ### 🎨 Adaptive Interface #### Integrated O-RedBrowser ```javascript class ORedSearchInterface { constructor(oredMindAPI) { this.ai = oredMindAPI; this.interfaceAdapter = new InterfaceAdapter(); this.searchHistory = new PrivateSearchHistory(); this.personalizer = new InterfacePersonalizer(); } adaptInterface(userProfile, searchContext) { // Adaptation based on active profile const profileAdaptation = this.interfaceAdapter.adaptToProfile( userProfile.activeProfile, userProfile.preferences ); // AI personalization const aiPersonalization = this.ai.personalizeInterface({ userExpertise: userProfile.expertiseLevel, searchPatterns: this.searchHistory.getPatterns(), currentContext: searchContext }); // Apply adaptations this.applyInterfaceChanges({ layout: profileAdaptation.layout, features: aiPersonalization.features, shortcuts: aiPersonalization.shortcuts, displayDensity: profileAdaptation.density }); } renderSearchResults(results, query) { return ( ); } } ``` ### πŸ” Conversational Search #### AI Search Assistant ```python class ConversationalSearch: def __init__(self, ored_mind_api): self.ai = ored_mind_api self.conversation_manager = ConversationManager() self.context_tracker = SearchContextTracker() def conversational_search(self, user_message, conversation_history): # Conversational understanding conversation_context = self.conversation_manager.understand_context( current_message=user_message, history=conversation_history, user_intent=self.ai.detect_search_intent(user_message) ) # Convert conversation to search query search_query = self.ai.convert_conversation_to_query( conversation_context=conversation_context, user_expertise=self.get_user_expertise_level(), search_goals=conversation_context.inferred_goals ) # Execute and analyze search_results = self.execute_search(search_query) analyzed_results = self.ai.analyze_results_for_conversation( results=search_results, conversation_context=conversation_context ) # Conversational response conversational_response = self.ai.generate_conversational_response( search_results=analyzed_results, conversation_style=self.get_user_conversation_style(), explanation_level=conversation_context.desired_detail_level ) return { 'response': conversational_response, 'sources': analyzed_results.sources, 'follow_up_suggestions': self.ai.suggest_follow_up_questions(conversation_context), 'conversation_state': self.conversation_manager.update_state(conversation_context) } ``` ## Security and Privacy ### πŸ›‘οΈ Advanced Protection #### Advanced Privacy Protection ```python class SearchPrivacyProtection: def __init__(self): self.query_anonymizer = QueryAnonymizer() self.traffic_protector = TrafficProtector() self.result_sanitizer = ResultSanitizer() self.metadata_scrubber = MetadataScrubber() def protect_search_privacy(self, search_request): # Anonymize the query anonymous_query = self.query_anonymizer.anonymize( query=search_request.query, user_id=search_request.user_id, anonymization_level='maximum' ) # Protect network traffic protected_traffic = self.traffic_protector.protect( request=anonymous_query, protection_methods=['tor_routing', 'traffic_mixing', 'timing_obfuscation'] ) # Execute protected search protected_results = self.execute_protected_search(protected_traffic) # Sanitize results sanitized_results = self.result_sanitizer.sanitize( results=protected_results, remove_tracking=True, anonymize_sources=True, clean_metadata=True ) # Remove metadata clean_results = self.metadata_scrubber.scrub(sanitized_results) return clean_results ``` ### πŸ” Audit and Transparency #### Transparency Framework ```python class SearchTransparencyFramework: def __init__(self): self.ranking_explainer = RankingExplainer() self.source_verifier = SourceVerifier() self.algorithm_auditor = AlgorithmAuditor() def explain_search_results(self, query, results, ranking_factors): # Explain ranking ranking_explanation = self.ranking_explainer.explain( query=query, results=results, factors=ranking_factors, explanation_level='detailed' ) # Verify sources source_verification = self.source_verifier.verify_sources( results=results, verification_criteria=['authenticity', 'authority', 'recency'] ) # Audit algorithms algorithm_transparency = self.algorithm_auditor.audit_decision_process( query=query, results=results, decision_path=ranking_explanation.decision_path ) return { 'ranking_explanation': ranking_explanation, 'source_verification': source_verification, 'algorithm_transparency': algorithm_transparency, 'bias_analysis': self.analyze_potential_bias(results) } ``` ## Performance and Scalability ### ⚑ Distributed Optimization #### Performance Optimization Engine ```python class DistributedPerformanceOptimizer: def __init__(self): self.load_balancer = DynamicLoadBalancer() self.cache_optimizer = DistributedCacheOptimizer() self.query_optimizer = QueryOptimizer() self.network_optimizer = NetworkOptimizer() def optimize_search_performance(self, search_load, network_conditions): # Optimize load distribution load_distribution = self.load_balancer.optimize_distribution( current_load=search_load, node_capacities=self.get_node_capacities(), performance_targets=self.get_performance_targets() ) # Optimize caching cache_strategy = self.cache_optimizer.optimize_caching( query_patterns=search_load.query_patterns, cache_hit_rates=self.get_cache_metrics(), storage_constraints=self.get_storage_limits() ) # Optimize queries query_optimizations = self.query_optimizer.optimize_queries( typical_queries=search_load.common_queries, index_structure=self.get_index_structure(), performance_bottlenecks=self.identify_bottlenecks() ) # Optimize network network_optimizations = self.network_optimizer.optimize_network( network_conditions=network_conditions, traffic_patterns=search_load.traffic_patterns, latency_requirements=self.get_latency_targets() ) return { 'load_distribution': load_distribution, 'cache_strategy': cache_strategy, 'query_optimizations': query_optimizations, 'network_optimizations': network_optimizations } ``` ## Governance and Quality ### πŸ›οΈ Community Governance #### Community Quality Control ```python class CommunityQualityGovernance: def __init__(self): self.quality_committee = CommunityQualityCommittee() self.reputation_system = ReputationSystem() self.voting_system = DecentralizedVoting() def manage_search_quality(self, quality_issues): # Community evaluation community_assessment = self.quality_committee.assess_issues( issues=quality_issues, community_input=self.gather_community_input(quality_issues), expert_opinions=self.get_expert_opinions(quality_issues) ) # Identify quality contributors quality_contributors = self.reputation_system.identify_quality_contributors( domain=community_assessment.affected_domain, contribution_type='quality_improvement' ) # Community vote for changes if community_assessment.requires_community_vote: voting_result = self.voting_system.conduct_quality_vote( proposal=community_assessment.improvement_proposal, eligible_voters=quality_contributors, voting_period=self.calculate_voting_period(community_assessment.complexity) ) if voting_result.approved: return self.implement_quality_improvements(community_assessment.improvement_proposal) return community_assessment ``` ## O-Red Ecosystem Integration ### πŸ”— Native Integration #### O-Red Ecosystem Integration ```python class ORedEcosystemIntegration: def __init__(self): self.ored_mind_api = ORedMindAPI() self.ored_store_api = ORedStoreAPI() self.ored_office_api = ORedOfficeAPI() self.ored_id_api = ORedIDAPI() def integrate_search_with_ecosystem(self, user_context): # Integrate with O-RedMind ai_enhancement = self.ored_mind_api.enhance_search( user_profile=user_context.profile, search_preferences=user_context.search_preferences ) # Integrate with O-RedStore app_recommendations = self.ored_store_api.recommend_apps_for_search( search_domain=user_context.current_domain, user_interests=user_context.interests ) # Integrate with O-RedOffice document_search = self.ored_office_api.search_user_documents( query=user_context.current_query, document_types=user_context.preferred_doc_types ) # O-RedID authentication authenticated_search = self.ored_id_api.authenticate_search( search_request=user_context.search_request, privacy_level=user_context.privacy_preferences ) return { 'ai_enhancement': ai_enhancement, 'app_recommendations': app_recommendations, 'document_search': document_search, 'authenticated_features': authenticated_search } ``` ## Development Roadmap ### 🎯 Phase 1 - Core Infrastructure (2026 Q3-Q4) - **Distributed Crawling** : Decentralized crawling system - **Basic Indexing** : Distributed index with replication - **Anonymous Search** : 100% anonymous search - **O-RedMind Integration** : Basic personal AI for search ### πŸš€ Phase 2 - Advanced Features (2027 Q1-Q2) - **Semantic Search** : Advanced semantic understanding - **Multilingual Search** : Intelligent multilingual search - **Real-time Results** : Real-time results - **Quality Assessment** : Automated quality assessment ### 🌟 Phase 3 - Augmented Intelligence (2027 Q3-Q4) - **Conversational Search** : Conversational AI interface - **Predictive Search** : Predict user's search needs - **Cross-domain Search** : Cross-domain search - **Advanced Personalization** : Ultra-advanced personalization ### πŸ† Phase 4 - Mature Ecosystem (2028) - **Universal Search** : Search across the entire O-Red ecosystem - **AI Research Assistant** : Ultra-intelligent research assistant - **Collaborative Search** : Team collaboration search - **Knowledge Graph** : Community-driven knowledge graph ## Revolutionary Impact ### 🌍 Transforming Search #### End of Mass Surveillance - **Privacy by Design** : Impossible to track searches - **Data Sovereignty** : No central data storage - **Anonymous Discovery** : Discover information without exposure - **Freedom Restored** : Authentic freedom to search #### New Information Paradigm - **Unbiased Results** : Objective results without manipulation - **Decentralized Authority** : Authority distributed among users - **Community Verification** : Community-verified sources - **Open Knowledge** : Equal access to information for all ## Conclusion O-RedSearch revolutionizes information search by creating the first engine where users fully control their privacy, where personal AI improves results without surveillance, and where the community guarantees quality and objectivity. **Your search belongs to you. O-RedSearch protects it.**