---
id: wiki-2026-0508-cognitive-computing
title: Cognitive Computing
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [cognitive computing, IBM Watson, autonomous agent, multimodal AI, contextual AI]
duplicate_of: none
source_trust_level: B
confidence_score: 0.83
verification_status: applied
tags: [cognitive-computing, agent, multimodal, contextual, llm, watson, ibm, history]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: AI history / current
  applicable_to: [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)
```python
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)
```python
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)
```python
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
```python
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)
```python
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|LLM]] · [[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 |
