1def match_ticker_with_context(text: str, candidates: List[str]) -> Dict[str, float]:
2    """
3    Match ticker symbols using foundational model context understanding
4    """
5    prompt = f"""
6    Given the financial context: "{text}"
7    
8    Rank these ticker candidates by relevance (0-1 confidence):
9    {', '.join(candidates)}
10    
11    Consider:
12    - Market context clues
13    - Industry terminology
14    - Geographic indicators
15    - Temporal references
16    
17    Return JSON: {{"ticker": confidence_score}}
18    """
19    
20    response = model.complete(prompt)
21    return parse_ticker_scores(response)

1import re
2from typing import Dict, List, Optional
3from dataclasses import dataclass
4from datetime import datetime
5
6@dataclass
7class TickerMatch:
8    symbol: str
9    confidence: float
10    reasoning: str
11    context_clues: List[str]
12
13class ContextualTickerMatcher:
14    def __init__(self, model_client):
15        self.model = model_client
16        self.known_tickers = self._load_ticker_database()
17        
18    def extract_context_features(self, text: str) -> Dict[str, any]:
19        """Extract contextual features from input text"""
20        features = {
21            'industries': [],
22            'geographic_mentions': [],
23            'temporal_indicators': [],
24            'financial_terms': [],
25            'sentiment_indicators': []
26        }
27        
28        # Industry detection
29        industry_patterns = {
30            'tech': r'\b(technology|software|AI|artificial intelligence|cloud|SaaS)\b',
31            'finance': r'\b(bank|financial|insurance|credit|loan)\b',
32            'healthcare': r'\b(pharma|biotech|medical|health|drug)\b',
33            'energy': r'\b(oil|gas|renewable|solar|wind|energy)\b'
34        }
35        
36        for industry, pattern in industry_patterns.items():
37            if re.search(pattern, text, re.IGNORECASE):
38                features['industries'].append(industry)
39        
40        # Geographic detection
41        geo_patterns = r'\b(NYSE|NASDAQ|LSE|TSE|ASX|European|American|Asian)\b'
42        features['geographic_mentions'] = re.findall(geo_patterns, text, re.IGNORECASE)
43        
44        # Temporal indicators
45        temporal_patterns = r'\b(Q[1-4]|quarterly|annual|YoY|monthly|recent|latest)\b'
46        features['temporal_indicators'] = re.findall(temporal_patterns, text, re.IGNORECASE)
47        
48        return features
49    
50    def match_with_context(self, text: str, max_results: int = 5) -> List[TickerMatch]:
51        """Match tickers using enhanced context analysis"""
52        context_features = self.extract_context_features(text)
53        
54        # Filter candidate tickers based on context
55        candidates = self._filter_candidates_by_context(context_features)
56        
57        matches = []
58        for ticker in candidates[:20]:  # Limit API calls
59            confidence = self._calculate_confidence(text, ticker, context_features)
60            if confidence > 0.3:  # Threshold for relevance
61                reasoning = self._generate_reasoning(ticker, context_features)
62                matches.append(TickerMatch(
63                    symbol=ticker['symbol'],
64                    confidence=confidence,
65                    reasoning=reasoning,
66                    context_clues=context_features.get('industries', [])
67                ))
68        
69        return sorted(matches, key=lambda x: x.confidence, reverse=True)[:max_results]

1interface TickerMatch {
2  symbol: string;
3  confidence: number;
4  reasoning: string;
5}
6
7interface KnownTicker {
8  symbol: string;
9  name: string;
10  exchange: string;
11  sector?: string;
12  industry?: string;
13}
14
15class TickerMatcher {
16  private knownTickers: KnownTicker[] = [
17    { symbol: "AAPL", name: "Apple Inc.", exchange: "NASDAQ", sector: "Technology" },
18    { symbol: "MSFT", name: "Microsoft Corporation", exchange: "NASDAQ", sector: "Technology" },
19    { symbol: "GOOGL", name: "Alphabet Inc.", exchange: "NASDAQ", sector: "Technology" },
20    { symbol: "TSLA", name: "Tesla, Inc.", exchange: "NASDAQ", sector: "Consumer Cyclical" },
21  ];
22
23  matchTicker(context: string): TickerMatch[] {
24    const results: TickerMatch[] = [];
25    
26    for (const ticker of this.knownTickers) {
27      const contextLower = context.toLowerCase();
28      const symbolLower = ticker.symbol.toLowerCase();
29      
30      let confidence = 0;
31      let reasons: string[] = [];
32      
33      // Direct symbol match (highest weight)
34      if (contextLower.includes(symbolLower)) {
35        confidence += 0.8;
36        reasons.push(`direct symbol match "${ticker.symbol}"`);
37      }
38      
39      // Company name matching
40      const nameWords = ticker.name.toLowerCase().split(' ');
41      const matchedWords = nameWords.filter(word => 
42        word.length > 2 && contextLower.includes(word)
43      );
44      
45      if (matchedWords.length > 0) {
46        const nameScore = (matchedWords.length / nameWords.length) * 0.7;
47        confidence += nameScore;
48        reasons.push(`company name match (${matchedWords.join(', ')})`);
49      }
50      
51      // Sector/industry context
52      if (ticker.sector && contextLower.includes(ticker.sector.toLowerCase())) {
53        confidence += 0.3;
54        reasons.push(`sector match (${ticker.sector})`);
55      }
56      
57      // Exchange context
58      if (contextLower.includes(ticker.exchange.toLowerCase())) {
59        confidence += 0.2;
60        reasons.push(`exchange match (${ticker.exchange})`);
61      }
62      
63      if (confidence > 0) {
64        results.push({
65          symbol: ticker.symbol,
66          confidence: Math.min(confidence, 1.0),
67          reasoning: `Found ${reasons.join(' and ')}`
68        });
69      }
70    }
71    
72    return results
73      .sort((a, b) => b.confidence - a.confidence)
74      .slice(0, 5);
75  }
76}
77
78// Usage example
79const matcher = new TickerMatcher();
80const context = "Apple reported strong iPhone sales in Q3, beating analyst expectations";
81const matches = matcher.matchTicker(context);
82
83console.log("Top matches:", matches);

1def detect_language_and_match(text: str) -> List[TickerMatch]:
2    """Handle multiple languages in ticker matching"""
3    
4    # Language detection
5    detected_lang = detect_language(text)
6    
7    if detected_lang in ['zh', 'ja', 'ko']:
8        # Asian markets have different ticker formats
9        return match_asian_tickers(text, detected_lang)
10    elif detected_lang in ['de', 'fr', 'es']:
11        # European markets
12        return match_european_tickers(text, detected_lang)
13    else:
14        # Default to US markets
15        return match_us_tickers(text)
16
17def match_asian_tickers(text: str, lang: str) -> List[TickerMatch]:
18    """Specialized matching for Asian markets"""
19    patterns = {
20        'zh': r'[\u4e00-\u9fff]+',  # Chinese characters
21        'ja': r'[\u3040-\u309f\u30a0-\u30ff]+',  # Hiragana/Katakana
22        'ko': r'[\uac00-\ud7af]+'  # Hangul
23    }
24    
25    # Extract company names in native script
26    native_names = re.findall(patterns.get(lang, r'\w+'), text)
27    
28    # Use specialized model for translation and matching
29    return translate_and_match(native_names, lang)

1import asyncio
2import websocket
3from datetime import datetime
4
5class RealTimeTickerMatcher:
6    def __init__(self):
7        self.market_data = {}
8        self.price_changes = {}
9        
10    async def start_market_feed(self):
11        """Start real-time market data feed"""
12        uri = "wss://api.marketdata.com/v1/stocks/quotes"
13        
14        async with websockets.connect(uri) as websocket:
15            await websocket.send(json.dumps({
16                "action": "subscribe",
17                "symbols": ["AAPL", "MSFT", "GOOGL", "TSLA"]
18            }))
19            
20            async for message in websocket:
21                data = json.loads(message)
22                self.update_market_data(data)
23    
24    def match_with_market_context(self, text: str) -> List[TickerMatch]:
25        """Enhanced matching using real-time market data"""
26        base_matches = self.match_ticker(text)
27        
28        # Boost confidence for tickers with significant price movements
29        for match in base_matches:
30            symbol = match.symbol
31            if symbol in self.price_changes:
32                price_change = abs(self.price_changes[symbol])
33                if price_change > 0.05:  # 5% threshold
34                    match.confidence *= 1.2
35                    match.reasoning += f" (active trading: {price_change:.1%})"
36        
37        return sorted(base_matches, key=lambda x: x.confidence, reverse=True)

1# Clone the repository
2git clone https://github.com/mcpalpha/ticker-matching-experiment.git
3cd ticker-matching-experiment
4
5# Create virtual environment
6python -m venv venv
7source venv/bin/activate  # On Windows: venv\Scripts\activate
8
9# Install dependencies
10pip install -r requirements.txt
11
12# Set environment variables
13export OPENAI_API_KEY="your-api-key-here"
14export MARKET_DATA_API_KEY="your-market-data-key"

1# config.py
2import os
3from dataclasses import dataclass
4
5@dataclass
6class Config:
7    openai_api_key: str = os.getenv("OPENAI_API_KEY")
8    model_name: str = "gpt-4"
9    max_tokens: int = 150
10    temperature: float = 0.1
11    confidence_threshold: float = 0.3
12    max_candidates: int = 20
13    
14    # Market data settings
15    market_data_api_key: str = os.getenv("MARKET_DATA_API_KEY")
16    update_interval: int = 5  # seconds
17    
18    # Caching settings
19    cache_ttl: int = 300  # 5 minutes
20    redis_url: str = os.getenv("REDIS_URL", "redis://localhost:6379")
21
22config = Config()

1# Run interactive demo
2python demo.py
3
4# Or use the API directly
5curl -X POST http://localhost:8000/match \
6  -H "Content-Type: application/json" \
7  -d '{"text": "Apple reported strong quarterly earnings"}'