2nd/10_Wiki/Topics/AI_and_ML/Cognitive Computing.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-cognitive-computing	Cognitive Computing	10_Wiki/Topics	verified	self	cognitive computing IBM Watson autonomous agent multimodal AI contextual AI	none	B	0.83	applied	cognitive-computing agent multimodal contextual llm watson ibm history		2026-05-10	pending	language applicable_to AI history / current Enterprise AI Multimodal Agent Watson Migration

Cognitive Computing

매 한 줄

"매 calculator 의 X — 매 cognitive partner". IBM Watson era 의 term 가, 매 modern: 매 LLM-based agentic system 의 redefine. 매 contextual + adaptive + multimodal + autonomous. 매 enterprise era 의 reference.

매 핵심

매 5 attribute (IBM 의 original)

1. Contextual: 매 situation 의 understand.
2. Adaptive: 매 self-learning.
3. Iterative + Stateful: 매 conversation 의 maintain.
4. Interactive: 매 multimodal interface.
5. Personalized.

매 history

IBM Watson (2011)

• Jeopardy champion (Brad Rutter, Ken Jennings).
• 매 hybrid (rules + ML).
• 매 enterprise (medical, finance) 의 push.
• 매 결국 매 narrow ROI.

IBM Watson Health (2015-2022)

• 매 oncology / diagnosis.
• 매 commercial failure.
• 매 sold off (Francisco Partners 2022).
• 매 lesson: 매 hype + 매 narrow capability gap.

Deep Blue (1997)

• 매 chess (Kasparov).
• 매 specialized.
• 매 cognitive computing 의 ancestor.

매 modern (2022+)

• 매 LLM 의 takeover.
• 매 ChatGPT, Claude, Gemini 의 cognitive computing 의 새 form.
• 매 agentic workflow.
• 매 multimodal native.

매 industry term 변화

Era	Term
1980s	Expert System
2010s	Cognitive Computing
2018-2022	AI / ML
2023+	Generative AI / LLM
2024+	Agentic AI

→ 매 hype cycle 의 typical.

매 enterprise application

1. Customer service: 매 chatbot.
2. Document understanding: 매 PDF parsing.
3. Knowledge management: 매 RAG.
4. Decision support: 매 medical diagnosis (caution).
5. Process automation: 매 RPA + LLM.
6. Personalization: 매 recommendation.

매 Watson → LLM migration

• 매 Watson 의 customer 의 LLM platform 의 transition.
• 매 case-based reasoning → 매 RAG.
• 매 NLU services → 매 LLM API.

💻 패턴 (응용 — modern equivalent)

Watson → LLM equivalent

Watson Service	LLM Equivalent
Watson Assistant (chatbot)	OpenAI Assistants / Claude with tools
Watson Discovery	Vector DB + RAG
Natural Language Understanding	LLM zero-shot
Watson Tone Analyzer	Sentiment via LLM
Watson Visual Recognition	GPT-4V / Claude vision / Gemini
Watson Speech	Whisper / Deepgram
Watson Knowledge Studio	LLM fine-tune

Modern cognitive system (RAG + agent)

from langchain.agents import create_react_agent
from langchain.vectorstores import Chroma
from langchain.tools import tool

# 매 knowledge base
kb = Chroma.from_documents(corporate_docs, embeddings)

@tool
def search_kb(query: str) -> str:
    """Search internal knowledge base."""
    return kb.similarity_search(query, k=5)

@tool
def search_web(query: str) -> str:
    """Search the web."""
    return search_engine(query)

agent = create_react_agent(
    llm=ChatOpenAI(model='gpt-4o'),
    tools=[search_kb, search_web, calculator, send_email],
    prompt=cognitive_prompt,
)

Multimodal (vision + speech + text)

from openai import OpenAI

client = OpenAI()

# 매 vision
vision_response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': [
            {'type': 'text', 'text': 'What is shown in this image?'},
            {'type': 'image_url', 'image_url': {'url': image_url}},
        ],
    }],
)

# 매 audio (Whisper)
audio_transcript = client.audio.transcriptions.create(
    model='whisper-1',
    file=audio_file,
)

# 매 speech synthesis
speech = client.audio.speech.create(
    model='tts-1',
    voice='alloy',
    input='Hello world',
)

Adaptive (online learning)

class AdaptiveAssistant:
    def __init__(self, base_llm):
        self.llm = base_llm
        self.user_profile = {}
    
    def respond(self, user_id, query):
        profile = self.user_profile.get(user_id, {})
        
        # 매 personalized prompt
        prompt = f"""User profile (learned over time):
- Communication style: {profile.get('style', 'unknown')}
- Expertise level: {profile.get('expertise', 'unknown')}
- Preferences: {profile.get('preferences', {})}

Query: {query}

Adapt response to this user."""
        
        response = self.llm.generate(prompt)
        return response
    
    def learn(self, user_id, feedback):
        # 매 update profile based on feedback
        if user_id not in self.user_profile:
            self.user_profile[user_id] = {}
        update_profile(self.user_profile[user_id], feedback)

Stateful conversation

class CognitiveSession:
    def __init__(self, max_history=20):
        self.history = []
        self.max_history = max_history
    
    def respond(self, user_input):
        self.history.append({'role': 'user', 'content': user_input})
        
        # 매 context window management
        if len(self.history) > self.max_history:
            old = self.history[:5]
            summary = summarize(old)
            self.history = [{'role': 'system', 'content': f'Earlier: {summary}'}] + self.history[5:]
        
        response = llm.chat(self.history)
        self.history.append({'role': 'assistant', 'content': response})
        return response

Enterprise integration (Watson-style replacement)

class EnterpriseAssistant:
    def __init__(self):
        self.kb = ChromaCollection('corporate_docs')
        self.crm = SalesforceClient()
        self.tickets = JiraClient()
        self.email = OutlookClient()
    
    def handle(self, user, query):
        # 매 context 의 enrich
        user_context = self.crm.get_user_context(user.id)
        recent_tickets = self.tickets.recent_for(user.id)
        
        # 매 RAG
        relevant_docs = self.kb.search(query, k=5)
        
        # 매 LLM 의 process
        response = llm.generate(f"""User: {user.name}, role: {user.role}
Recent tickets: {recent_tickets}
Relevant docs: {relevant_docs}

Query: {query}

Provide a tailored response with citations.""")
        
        # 매 action 의 execute (if needed)
        if requires_action(response):
            execute_action(response, user)
        
        return response

🤔 결정 기준

상황	Modern Approach
Q&A	LLM + RAG
Multi-step task	Agent (LangChain)
Multimodal	GPT-4V / Claude / Gemini
Voice	Whisper + LLM + TTS
Specialized domain	Fine-tune (LoRA) + RAG
Watson migration	OpenAI / Anthropic / Bedrock + custom
Privacy-critical	Self-hosted Llama / Mistral

기본값: 매 cognitive computing 의 modern form 의 LLM agent + RAG + multimodal.

🔗 Graph

• 부모: AI
• 변형: IBM-Watson
• 응용: Transformer_Architecture_and_LLM_Foundations · RAG · Multimodal-AI · Cognitive-Architecture
• Adjacent: Artificial-Intelligence · Biological-Intelligence · Bayesian-Brain-Hypothesis · Beliefs

🤖 LLM 활용

언제: 매 enterprise AI strategy. 매 Watson migration. 매 contextual assistant. 매 multimodal app. 언제 X: 매 simple lookup (no cognition needed). 매 deterministic rule.

❌ 안티패턴

• Cognitive computing 의 hype 의 buy: 매 narrow capability 의 general expectation.
• Watson era 의 stuck: 매 LLM 의 leverage X.
• No state / context: 매 cognitive 의 X.
• Single-modal limit: 매 modern 의 multimodal expect.
• No personalization: 매 generic 의 only.

🧪 검증 / 중복

• Verified (IBM Watson history, modern LLM era).
• 신뢰도 B.
• Related: Cognitive-Architecture · Artificial-Intelligence · Biological-Intelligence · Asset-Specific-Knowledge (RAG).

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Watson history + modern equivalent + 매 RAG / multimodal / adaptive code